llvm.org GIT mirror llvm / dca6cdd
Added the infrastructute necessary for MIPS JIT support. Patch by Vladimir Stefanovic. I removed the part that actually emits the instructions cause I want that to get in better shape first and in incremental steps. This also makes it easier to review the upcoming parts. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@135678 91177308-0d34-0410-b5e6-96231b3b80d8 Bruno Cardoso Lopes 9 years ago
12 changed file(s) with 522 addition(s) and 6 deletion(s). Raw diff Collapse all Expand all
8181 )
8282
8383 # List of targets with JIT support:
84 set(LLVM_TARGETS_WITH_JIT X86 PowerPC ARM)
84 set(LLVM_TARGETS_WITH_JIT X86 PowerPC ARM Mips)
8585
8686 if( MSVC )
8787 set(LLVM_TARGETS_TO_BUILD X86
483483 x86_64) AC_SUBST(TARGET_HAS_JIT,1) ;;
484484 Alpha) AC_SUBST(TARGET_HAS_JIT,0) ;;
485485 ARM) AC_SUBST(TARGET_HAS_JIT,1) ;;
486 Mips) AC_SUBST(TARGET_HAS_JIT,0) ;;
486 Mips) AC_SUBST(TARGET_HAS_JIT,1) ;;
487487 XCore) AC_SUBST(TARGET_HAS_JIT,0) ;;
488488 MSP430) AC_SUBST(TARGET_HAS_JIT,0) ;;
489489 SystemZ) AC_SUBST(TARGET_HAS_JIT,0) ;;
48644864 ;;
48654865 ARM) TARGET_HAS_JIT=1
48664866 ;;
4867 Mips) TARGET_HAS_JIT=0
4867 Mips) TARGET_HAS_JIT=1
48684868 ;;
48694869 XCore) TARGET_HAS_JIT=0
48704870 ;;
88
99 add_llvm_target(MipsCodeGen
1010 MipsAsmPrinter.cpp
11 MipsCodeEmitter.cpp
1112 MipsDelaySlotFiller.cpp
1213 MipsEmitGPRestore.cpp
1314 MipsExpandPseudo.cpp
2828 FunctionPass *createMipsExpandPseudoPass(MipsTargetMachine &TM);
2929 FunctionPass *createMipsEmitGPRestorePass(MipsTargetMachine &TM);
3030
31 FunctionPass *createMipsJITCodeEmitterPass(MipsTargetMachine &TM,
32 JITCodeEmitter &JCE);
33
3134 } // end namespace llvm;
3235
3336 #endif
0 //===-- Mips/MipsCodeEmitter.cpp - Convert Mips code to machine code -----===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===---------------------------------------------------------------------===//
8 //
9 // This file contains the pass that transforms the Mips machine instructions
10 // into relocatable machine code.
11 //
12 //===---------------------------------------------------------------------===//
13
14 #define DEBUG_TYPE "jit"
15 #include "Mips.h"
16 #include "MipsInstrInfo.h"
17 #include "MipsRelocations.h"
18 #include "MipsSubtarget.h"
19 #include "MipsTargetMachine.h"
20 #include "llvm/Constants.h"
21 #include "llvm/DerivedTypes.h"
22 #include "llvm/Function.h"
23 #include "llvm/PassManager.h"
24 #include "llvm/CodeGen/JITCodeEmitter.h"
25 #include "llvm/CodeGen/MachineConstantPool.h"
26 #include "llvm/CodeGen/MachineFunctionPass.h"
27 #include "llvm/CodeGen/MachineInstr.h"
28 #include "llvm/CodeGen/MachineJumpTableInfo.h"
29 #include "llvm/CodeGen/MachineModuleInfo.h"
30 #include "llvm/CodeGen/Passes.h"
31 #include "llvm/ADT/Statistic.h"
32 #include "llvm/Support/Debug.h"
33 #include "llvm/Support/ErrorHandling.h"
34 #include "llvm/Support/raw_ostream.h"
35 #ifndef NDEBUG
36 #include
37 #endif
38
39 #include "llvm/CodeGen/MachineOperand.h"
40
41 using namespace llvm;
42
43 namespace {
44
45 class MipsCodeEmitter : public MachineFunctionPass {
46 MipsJITInfo *JTI;
47 const MipsInstrInfo *II;
48 const TargetData *TD;
49 const MipsSubtarget *Subtarget;
50 TargetMachine &TM;
51 JITCodeEmitter &MCE;
52 const std::vector *MCPEs;
53 const std::vector *MJTEs;
54 bool IsPIC;
55
56 void getAnalysisUsage(AnalysisUsage &AU) const {
57 AU.addRequired ();
58 MachineFunctionPass::getAnalysisUsage(AU);
59 }
60
61 static char ID;
62
63 public:
64 MipsCodeEmitter(TargetMachine &tm, JITCodeEmitter &mce) :
65 MachineFunctionPass(ID), JTI(0),
66 II((const MipsInstrInfo *) tm.getInstrInfo()),
67 TD(tm.getTargetData()), TM(tm), MCE(mce), MCPEs(0), MJTEs(0),
68 IsPIC(TM.getRelocationModel() == Reloc::PIC_) {
69 }
70
71 bool runOnMachineFunction(MachineFunction &MF);
72
73 virtual const char *getPassName() const {
74 return "Mips Machine Code Emitter";
75 }
76
77 void emitInstruction(const MachineInstr &MI);
78
79 unsigned getOperandValue(const MachineOperand &MO,
80 unsigned relocType = -1);
81
82 void emitGlobalAddress(const GlobalValue *GV, unsigned Reloc,
83 bool MayNeedFarStub = true);
84
85 void emitMachineBasicBlock(MachineBasicBlock *BB, unsigned Reloc,
86 intptr_t JTBase = 0);
87
88 void emitExternalSymbolAddress(const char *ES, unsigned Reloc);
89 void emitJumpTableAddress(unsigned JTIndex, unsigned Reloc) const;
90 void emitConstPoolAddress(unsigned CPI, unsigned Reloc);
91 };
92 }
93
94 void MipsCodeEmitter::emitGlobalAddress(const GlobalValue *GV, unsigned Reloc,
95 bool mayNeedFarStub) {
96 MachineRelocation MR = MachineRelocation::getGV(MCE.getCurrentPCOffset(),
97 Reloc, const_cast (GV), 0, mayNeedFarStub);
98 MCE.addRelocation(MR);
99 }
100
101 /// emitMachineBasicBlock - Emit the specified address basic block.
102 void MipsCodeEmitter::emitMachineBasicBlock(MachineBasicBlock *BB,
103 unsigned Reloc, intptr_t JTBase) {
104 MCE.addRelocation(
105 MachineRelocation::getBB(MCE.getCurrentPCOffset(), Reloc, BB, JTBase));
106 }
107
108 void MipsCodeEmitter::emitExternalSymbolAddress(const char *ES,
109 unsigned Reloc) {
110 MCE.addRelocation(
111 MachineRelocation::getExtSym(MCE.getCurrentPCOffset(), Reloc, ES, 0, 0,
112 false));
113 }
114
115 void MipsCodeEmitter::emitJumpTableAddress(unsigned JTIndex, unsigned Reloc)
116 const {
117 MCE.addRelocation(
118 MachineRelocation::getJumpTable(MCE.getCurrentPCOffset(), Reloc, JTIndex,
119 0, false));
120 }
121
122 void MipsCodeEmitter::emitConstPoolAddress(unsigned CPI, unsigned Reloc) {
123 MCE.addRelocation(
124 MachineRelocation::getConstPool
125 (MCE.getCurrentPCOffset(), Reloc, CPI, 0));
126 }
127
128 /// createMipsJITCodeEmitterPass - Return a pass that emits the collected Mips
129 /// code to the specified MCE object.
130 FunctionPass *llvm::createMipsJITCodeEmitterPass(MipsTargetMachine &TM,
131 JITCodeEmitter &JCE) {
132 return new MipsCodeEmitter(TM, JCE);
133 }
134
135 char MipsCodeEmitter::ID = 10;
136
137 bool MipsCodeEmitter::runOnMachineFunction(MachineFunction &MF) {
138 JTI = ((MipsTargetMachine&) MF.getTarget()).getJITInfo();
139 II = ((const MipsTargetMachine&) MF.getTarget()).getInstrInfo();
140 TD = ((const MipsTargetMachine&) MF.getTarget()).getTargetData();
141 Subtarget = &TM.getSubtarget ();
142 MCPEs = &MF.getConstantPool()->getConstants();
143 MJTEs = 0;
144 if (MF.getJumpTableInfo()) MJTEs = &MF.getJumpTableInfo()->getJumpTables();
145 JTI->Initialize(MF, IsPIC);
146 MCE.setModuleInfo(&getAnalysis ());
147
148 do {
149 DEBUG(errs() << "JITTing function '"
150 << MF.getFunction()->getName() << "'\n");
151 MCE.startFunction(MF);
152
153 for (MachineFunction::iterator MBB = MF.begin(), E = MF.end();
154 MBB != E; ++MBB){
155 MCE.StartMachineBasicBlock(MBB);
156 for (MachineBasicBlock::const_iterator I = MBB->begin(), E = MBB->end();
157 I != E; ++I)
158 emitInstruction(*I);
159 }
160 } while (MCE.finishFunction(MF));
161
162 return false;
163 }
164
165 void MipsCodeEmitter::emitInstruction(const MachineInstr &MI) {}
166
167 unsigned MipsCodeEmitter::getOperandValue(const MachineOperand &MO,
168 unsigned relocType) {
169 switch (MO.getType()) {
170 case MachineOperand::MO_Immediate:
171 return MO.getImm();
172 case MachineOperand::MO_GlobalAddress:
173 emitGlobalAddress(MO.getGlobal(), relocType, false);
174 return 0;
175 case MachineOperand::MO_ExternalSymbol:
176 emitExternalSymbolAddress(MO.getSymbolName(), relocType);
177 return 0;
178 case MachineOperand::MO_MachineBasicBlock:
179 emitMachineBasicBlock(MO.getMBB(), relocType, MCE.getCurrentPCValue());
180 return 0;
181 case MachineOperand::MO_Register:
182 return MipsRegisterInfo::getRegisterNumbering(MO.getReg());
183 case MachineOperand::MO_JumpTableIndex:
184 emitJumpTableAddress(MO.getIndex(), relocType);
185 return 0;
186 case MachineOperand::MO_ConstantPoolIndex:
187 emitConstPoolAddress(MO.getIndex(), relocType);
188 return 0;
189 default: return 0;
190 }
191 }
192
0 //===- MipsJITInfo.cpp - Implement the JIT interfaces for the Mips target -===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the JIT interfaces for the Mips target.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #define DEBUG_TYPE "jit"
14 #include "MipsJITInfo.h"
15 #include "MipsInstrInfo.h"
16 #include "MipsRelocations.h"
17 #include "MipsSubtarget.h"
18 #include "llvm/Function.h"
19 #include "llvm/CodeGen/JITCodeEmitter.h"
20 #include "llvm/Support/Debug.h"
21 #include "llvm/Support/ErrorHandling.h"
22 #include "llvm/Support/raw_ostream.h"
23 #include "llvm/Support/Memory.h"
24 #include
25 using namespace llvm;
26
27
28 void MipsJITInfo::replaceMachineCodeForFunction(void *Old, void *New) {
29 report_fatal_error("MipsJITInfo::replaceMachineCodeForFunction");
30 }
31
32 /// JITCompilerFunction - This contains the address of the JIT function used to
33 /// compile a function lazily.
34 static TargetJITInfo::JITCompilerFn JITCompilerFunction;
35
36 // Get the ASMPREFIX for the current host. This is often '_'.
37 #ifndef __USER_LABEL_PREFIX__
38 #define __USER_LABEL_PREFIX__
39 #endif
40 #define GETASMPREFIX2(X) #X
41 #define GETASMPREFIX(X) GETASMPREFIX2(X)
42 #define ASMPREFIX GETASMPREFIX(__USER_LABEL_PREFIX__)
43
44 // save registers, call MipsCompilationCallbackC, restore registers
45 extern "C" {
46 #if defined (__mips__)
47 void MipsCompilationCallback();
48
49 asm(
50 ".text\n"
51 ".align 2\n"
52 ".globl " ASMPREFIX "MipsCompilationCallback\n"
53 ASMPREFIX "MipsCompilationCallback:\n"
54 ".ent " ASMPREFIX "MipsCompilationCallback\n"
55 ".set noreorder\n"
56 ".cpload $t9\n"
57 ".frame $29, 32, $31\n"
58
59 "addiu $sp, $sp, -40\n"
60 "sw $a0, 4($sp)\n"
61 "sw $a1, 8($sp)\n"
62 "sw $a2, 12($sp)\n"
63 "sw $a3, 20($sp)\n"
64 "sw $ra, 24($sp)\n"
65 "sw $v0, 28($sp)\n"
66 "sw $v1, 32($sp)\n"
67 "sw $t8, 36($sp)\n"
68 ".cprestore 16\n"
69
70 "addiu $a0, $t8, -16\n"
71 "jal " ASMPREFIX "MipsCompilationCallbackC\n"
72 "nop\n"
73
74 "lw $a0, 4($sp)\n"
75 "lw $a1, 8($sp)\n"
76 "lw $a2, 12($sp)\n"
77 "lw $a3, 20($sp)\n"
78 "lw $ra, 24($sp)\n"
79 "lw $v0, 28($sp)\n"
80 "lw $v1, 32($sp)\n"
81 "lw $t8, 36($sp)\n"
82 "addiu $sp, $sp, 40\n"
83
84 "addiu $t8, $t8, -16\n"
85 "jr $t8\n"
86 "nop\n"
87
88 ".set reorder\n"
89 ".end " ASMPREFIX "MipsCompilationCallback\n"
90 );
91 #else // host != Mips
92 void MipsCompilationCallback() {
93 llvm_unreachable(
94 "Cannot call MipsCompilationCallback() on a non-Mips arch!");
95 }
96 #endif
97 }
98
99 /// MipsCompilationCallbackC - This is the target-specific function invoked
100 /// by the function stub when we did not know the real target of a call.
101 /// This function must locate the start of the stub or call site and pass
102 /// it into the JIT compiler function.
103 extern "C" void MipsCompilationCallbackC(intptr_t StubAddr) {
104
105 // Get the address of the compiled code for this function.
106 intptr_t NewVal = (intptr_t) JITCompilerFunction((void*) StubAddr);
107
108 *(intptr_t *) (StubAddr) = 2 << 26 | ((NewVal & 0x0fffffff) >> 2); // J NewVal
109 *(intptr_t *) (StubAddr + 4) = 0; // NOP
110 *(intptr_t *) (StubAddr + 8) = 0; // NOP
111 *(intptr_t *) (StubAddr + 12) = 0; // NOP
112
113 sys::Memory::InvalidateInstructionCache((void*) StubAddr, 16);
114 }
115
116 TargetJITInfo::LazyResolverFn MipsJITInfo::getLazyResolverFunction(
117 JITCompilerFn F) {
118 JITCompilerFunction = F;
119 return MipsCompilationCallback;
120 }
121
122 TargetJITInfo::StubLayout MipsJITInfo::getStubLayout() {
123 StubLayout Result = { 24, 4 }; // {Size. Alignment} (of FunctionStub)
124 return Result;
125 }
126
127 void *MipsJITInfo::emitFunctionStub(const Function* F, void *Fn,
128 JITCodeEmitter &JCE) {
129 JCE.emitAlignment(4);
130 void *Addr = (void*) (JCE.getCurrentPCValue());
131
132 unsigned arg0 = ((intptr_t) MipsCompilationCallback >> 16);
133 if ((((intptr_t) MipsCompilationCallback & 0xffff) >> 15) == 1) {
134 arg0 += 1; // same hack as in relocate()
135 }
136
137 // LUI t9, %hi(MipsCompilationCallback)
138 JCE.emitWordLE(0xf << 26 | 25 << 16 | arg0);
139 // ADDiu t9, t9, %lo(MipsCompilationCallback)
140 JCE.emitWordLE(9 << 26 | 25 << 21 | 25 << 16
141 | ((intptr_t) MipsCompilationCallback & 0xffff));
142 // JALR t8, t9
143 JCE.emitWordLE(25 << 21 | 24 << 11 | 9);
144 JCE.emitWordLE(0); // NOP
145
146 sys::Memory::InvalidateInstructionCache((void*) Addr, 16);
147
148 return Addr;
149 }
150
151 /// relocate - Before the JIT can run a block of code that has been emitted,
152 /// it must rewrite the code to contain the actual addresses of any
153 /// referenced global symbols.
154 void MipsJITInfo::relocate(void *Function, MachineRelocation *MR,
155 unsigned NumRelocs, unsigned char* GOTBase) {
156 for (unsigned i = 0; i != NumRelocs; ++i, ++MR) {
157
158 void *RelocPos = (char*) Function + MR->getMachineCodeOffset();
159 intptr_t ResultPtr = (intptr_t) MR->getResultPointer();
160
161 switch ((Mips::RelocationType) MR->getRelocationType()) {
162 case Mips::reloc_mips_pcrel:
163 ResultPtr = (((ResultPtr - (intptr_t) RelocPos) - 4) >> 2) & 0xffff;
164 *((unsigned*) RelocPos) |= (unsigned) ResultPtr;
165 break;
166
167 case Mips::reloc_mips_j_jal: {
168 ResultPtr = (ResultPtr & 0x0fffffff) >> 2;
169 *((unsigned*) RelocPos) |= (unsigned) ResultPtr;
170 }
171 break;
172
173 case Mips::reloc_mips_hi: {
174 ResultPtr = ResultPtr >> 16;
175
176 // see See MIPS Run Linux, chapter 9.4
177 if ((((intptr_t) (MR->getResultPointer()) & 0xffff) >> 15) == 1) {
178 ResultPtr += 1;
179 }
180
181 *((unsigned*) RelocPos) |= (unsigned) ResultPtr;
182 }
183 break;
184
185 case Mips::reloc_mips_lo:
186 ResultPtr = ResultPtr & 0xffff;
187 *((unsigned*) RelocPos) |= (unsigned) ResultPtr;
188 break;
189
190 default:
191 assert(0 && "MipsJITInfo.unknown relocation;");
192 }
193 }
194 }
0 //===- MipsJITInfo.h - Mips implementation of the JIT interface -*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains the declaration of the MipsJITInfo class.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #ifndef MIPSJITINFO_H
14 #define MIPSJITINFO_H
15
16 #include "MipsMachineFunction.h"
17 #include "llvm/CodeGen/MachineConstantPool.h"
18 #include "llvm/CodeGen/MachineFunction.h"
19 #include "llvm/CodeGen/MachineJumpTableInfo.h"
20 #include "llvm/Target/TargetJITInfo.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/SmallVector.h"
23
24 namespace llvm {
25 class MipsTargetMachine;
26
27 class MipsJITInfo : public TargetJITInfo {
28
29 bool IsPIC;
30
31 public:
32 explicit MipsJITInfo() :
33 IsPIC(false) {}
34
35 /// replaceMachineCodeForFunction - Make it so that calling the function
36 /// whose machine code is at OLD turns into a call to NEW, perhaps by
37 /// overwriting OLD with a branch to NEW. This is used for self-modifying
38 /// code.
39 ///
40 virtual void replaceMachineCodeForFunction(void *Old, void *New);
41
42 // getStubLayout - Returns the size and alignment of the largest call stub
43 // on Mips.
44 virtual StubLayout getStubLayout();
45
46 /// emitFunctionStub - Use the specified JITCodeEmitter object to emit a
47 /// small native function that simply calls the function at the specified
48 /// address.
49 virtual void *emitFunctionStub(const Function* F, void *Fn,
50 JITCodeEmitter &JCE);
51
52 /// getLazyResolverFunction - Expose the lazy resolver to the JIT.
53 virtual LazyResolverFn getLazyResolverFunction(JITCompilerFn);
54
55 /// relocate - Before the JIT can run a block of code that has been emitted,
56 /// it must rewrite the code to contain the actual addresses of any
57 /// referenced global symbols.
58 virtual void relocate(void *Function, MachineRelocation *MR,
59 unsigned NumRelocs, unsigned char* GOTBase);
60
61 /// Initialize - Initialize internal stage for the function being JITted.
62 void Initialize(const MachineFunction &MF, bool isPIC) {
63 IsPIC = isPIC;
64 }
65
66 };
67 }
68
69 #endif
0 //===- MipsRelocations.h - Mips Code Relocations ---------------*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===---------------------------------------------------------------------===//
8 //
9 // This file defines the Mips target-specific relocation types
10 // (for relocation-model=static).
11 //
12 //===---------------------------------------------------------------------===//
13
14 #ifndef MIPSRELOCATIONS_H_
15 #define MIPSRELOCATIONS_H_
16
17 #include "llvm/CodeGen/MachineRelocation.h"
18
19 namespace llvm {
20 namespace Mips{
21 enum RelocationType {
22 reloc_mips_pcrel = 1,
23 reloc_mips_hi = 3,
24 reloc_mips_lo = 4,
25 reloc_mips_j_jal = 5
26 };
27 }
28 }
29
30 #endif /* MIPSRELOCATIONS_H_ */
31
4141 std::string("E-p:32:32:32-i8:8:32-i16:16:32-i64:64:64-n32")),
4242 InstrInfo(*this),
4343 FrameLowering(Subtarget),
44 TLInfo(*this), TSInfo(*this) {
44 TLInfo(*this), TSInfo(*this), JITInfo() {
4545 }
4646
4747 MipselTargetMachine::
8080 PM.add(createMipsExpandPseudoPass(*this));
8181 return true;
8282 }
83
84 bool MipsTargetMachine::addCodeEmitter(PassManagerBase &PM,
85 CodeGenOpt::Level OptLevel,
86 JITCodeEmitter &JCE) {
87 // Machine code emitter pass for Mips.
88 PM.add(createMipsJITCodeEmitterPass(*this, JCE));
89 return false;
90 }
91
2121 #include "llvm/Target/TargetMachine.h"
2222 #include "llvm/Target/TargetData.h"
2323 #include "llvm/Target/TargetFrameLowering.h"
24 #include "MipsJITInfo.h"
2425
2526 namespace llvm {
2627 class formatted_raw_ostream;
3233 MipsFrameLowering FrameLowering;
3334 MipsTargetLowering TLInfo;
3435 MipsSelectionDAGInfo TSInfo;
36 MipsJITInfo JITInfo;
37 Reloc::Model DefRelocModel; // Reloc model before it's overridden.
38
3539 public:
3640 MipsTargetMachine(const Target &T, StringRef TT,
3741 StringRef CPU, StringRef FS,
4650 { return &Subtarget; }
4751 virtual const TargetData *getTargetData() const
4852 { return &DataLayout;}
53 virtual MipsJITInfo *getJITInfo()
54 { return &JITInfo; }
55
4956
5057 virtual const MipsRegisterInfo *getRegisterInfo() const {
5158 return &InstrInfo.getRegisterInfo();
6774 virtual bool addPreRegAlloc(PassManagerBase &PM,
6875 CodeGenOpt::Level OptLevel);
6976 virtual bool addPostRegAlloc(PassManagerBase &, CodeGenOpt::Level);
77 virtual bool addCodeEmitter(PassManagerBase &PM,
78 CodeGenOpt::Level OptLevel,
79 JITCodeEmitter &JCE);
80
7081 };
7182
7283 /// MipselTargetMachine - Mipsel target machine.
1414 Target llvm::TheMipsTarget, llvm::TheMipselTarget;
1515
1616 extern "C" void LLVMInitializeMipsTargetInfo() {
17 RegisterTarget> X(TheMipsTarget, "mips", "Mips");
17 RegisterTarget,
18 /*HasJIT=*/true> X(TheMipsTarget, "mips", "Mips");
1819
19 RegisterTarget> Y(TheMipselTarget, "mipsel", "Mipsel");
20 RegisterTarget,
21 /*HasJIT=*/true> Y(TheMipselTarget, "mipsel", "Mipsel");
2022 }