Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 1 | //===-- X86AsmPrinter.cpp - Convert X86 LLVM code to AT&T assembly --------===// |
Misha Brukman | c88330a | 2005-04-21 23:38:14 +0000 | [diff] [blame] | 2 | // |
John Criswell | 482202a | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | f3ebc3f | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | c88330a | 2005-04-21 23:38:14 +0000 | [diff] [blame] | 7 | // |
John Criswell | 482202a | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | d92fb00 | 2002-10-25 22:55:53 +0000 | [diff] [blame] | 9 | // |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 10 | // This file contains a printer that converts from our internal representation |
Chris Lattner | 94a946c | 2010-01-28 01:02:27 +0000 | [diff] [blame] | 11 | // of machine-dependent LLVM code to X86 machine code. |
Chris Lattner | d92fb00 | 2002-10-25 22:55:53 +0000 | [diff] [blame] | 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 15 | #include "X86AsmPrinter.h" |
Chandler Carruth | ed0881b | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 16 | #include "InstPrinter/X86ATTInstPrinter.h" |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 17 | #include "X86.h" |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 18 | #include "X86COFFMachineModuleInfo.h" |
| 19 | #include "X86MachineFunctionInfo.h" |
| 20 | #include "X86TargetMachine.h" |
Chandler Carruth | ed0881b | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 21 | #include "llvm/ADT/SmallString.h" |
| 22 | #include "llvm/Assembly/Writer.h" |
Chandler Carruth | ed0881b | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 23 | #include "llvm/CodeGen/MachineJumpTableInfo.h" |
| 24 | #include "llvm/CodeGen/MachineModuleInfoImpls.h" |
| 25 | #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h" |
Bill Wendling | e38859d | 2012-06-28 00:05:13 +0000 | [diff] [blame] | 26 | #include "llvm/DebugInfo.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 27 | #include "llvm/IR/CallingConv.h" |
| 28 | #include "llvm/IR/DerivedTypes.h" |
| 29 | #include "llvm/IR/Module.h" |
| 30 | #include "llvm/IR/Type.h" |
Bill Wendling | f1eae22 | 2010-03-09 00:40:17 +0000 | [diff] [blame] | 31 | #include "llvm/MC/MCAsmInfo.h" |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 32 | #include "llvm/MC/MCContext.h" |
Chris Lattner | 3bcbdb8 | 2010-02-03 06:42:38 +0000 | [diff] [blame] | 33 | #include "llvm/MC/MCExpr.h" |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 34 | #include "llvm/MC/MCSectionMachO.h" |
| 35 | #include "llvm/MC/MCStreamer.h" |
| 36 | #include "llvm/MC/MCSymbol.h" |
Chris Lattner | 2548580 | 2010-07-14 18:14:33 +0000 | [diff] [blame] | 37 | #include "llvm/Support/COFF.h" |
Devang Patel | 2bf0f3c | 2010-08-04 18:06:05 +0000 | [diff] [blame] | 38 | #include "llvm/Support/Debug.h" |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 39 | #include "llvm/Support/ErrorHandling.h" |
Evan Cheng | 2bb4035 | 2011-08-24 18:08:43 +0000 | [diff] [blame] | 40 | #include "llvm/Support/TargetRegistry.h" |
Chandler Carruth | ed0881b | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 41 | #include "llvm/Target/Mangler.h" |
| 42 | #include "llvm/Target/TargetOptions.h" |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 43 | using namespace llvm; |
| 44 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 45 | //===----------------------------------------------------------------------===// |
| 46 | // Primitive Helper Functions. |
| 47 | //===----------------------------------------------------------------------===// |
| 48 | |
Chris Lattner | 94a946c | 2010-01-28 01:02:27 +0000 | [diff] [blame] | 49 | /// runOnMachineFunction - Emit the function body. |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 50 | /// |
| 51 | bool X86AsmPrinter::runOnMachineFunction(MachineFunction &MF) { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 52 | SetupMachineFunction(MF); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 53 | |
Evan Cheng | d22a4a1 | 2011-02-01 01:14:13 +0000 | [diff] [blame] | 54 | if (Subtarget->isTargetCOFF() && !Subtarget->isTargetEnvMacho()) { |
Chris Lattner | 72afa95 | 2010-05-08 19:54:22 +0000 | [diff] [blame] | 55 | bool Intrn = MF.getFunction()->hasInternalLinkage(); |
| 56 | OutStreamer.BeginCOFFSymbolDef(CurrentFnSym); |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 57 | OutStreamer.EmitCOFFSymbolStorageClass(Intrn ? COFF::IMAGE_SYM_CLASS_STATIC |
Chris Lattner | 2548580 | 2010-07-14 18:14:33 +0000 | [diff] [blame] | 58 | : COFF::IMAGE_SYM_CLASS_EXTERNAL); |
| 59 | OutStreamer.EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION |
| 60 | << COFF::SCT_COMPLEX_TYPE_SHIFT); |
Chris Lattner | 72afa95 | 2010-05-08 19:54:22 +0000 | [diff] [blame] | 61 | OutStreamer.EndCOFFSymbolDef(); |
Chris Lattner | c7b9115 | 2010-01-26 23:18:44 +0000 | [diff] [blame] | 62 | } |
Anton Korobeynikov | c9276df | 2010-02-12 15:28:40 +0000 | [diff] [blame] | 63 | |
Chris Lattner | c7b9115 | 2010-01-26 23:18:44 +0000 | [diff] [blame] | 64 | // Have common code print out the function header with linkage info etc. |
| 65 | EmitFunctionHeader(); |
Anton Korobeynikov | c9276df | 2010-02-12 15:28:40 +0000 | [diff] [blame] | 66 | |
Chris Lattner | 94a946c | 2010-01-28 01:02:27 +0000 | [diff] [blame] | 67 | // Emit the rest of the function body. |
| 68 | EmitFunctionBody(); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 69 | |
| 70 | // We didn't modify anything. |
| 71 | return false; |
| 72 | } |
| 73 | |
| 74 | /// printSymbolOperand - Print a raw symbol reference operand. This handles |
| 75 | /// jump tables, constant pools, global address and external symbols, all of |
| 76 | /// which print to a label with various suffixes for relocation types etc. |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 77 | static void printSymbolOperand(X86AsmPrinter &P, const MachineOperand &MO, |
| 78 | raw_ostream &O) { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 79 | switch (MO.getType()) { |
| 80 | default: llvm_unreachable("unknown symbol type!"); |
| 81 | case MachineOperand::MO_JumpTableIndex: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 82 | O << *P.GetJTISymbol(MO.getIndex()); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 83 | break; |
| 84 | case MachineOperand::MO_ConstantPoolIndex: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 85 | O << *P.GetCPISymbol(MO.getIndex()); |
| 86 | P.printOffset(MO.getOffset(), O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 87 | break; |
| 88 | case MachineOperand::MO_GlobalAddress: { |
| 89 | const GlobalValue *GV = MO.getGlobal(); |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 90 | |
Chris Lattner | 8c21ffd | 2010-01-18 00:59:24 +0000 | [diff] [blame] | 91 | MCSymbol *GVSym; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 92 | if (MO.getTargetFlags() == X86II::MO_DARWIN_STUB) |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 93 | GVSym = P.GetSymbolWithGlobalValueBase(GV, "$stub"); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 94 | else if (MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY || |
| 95 | MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY_PIC_BASE || |
| 96 | MO.getTargetFlags() == X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE) |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 97 | GVSym = P.GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); |
Chris Lattner | e6b1bef | 2010-01-16 00:51:39 +0000 | [diff] [blame] | 98 | else |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 99 | GVSym = P.getSymbol(GV); |
Chris Lattner | e6b1bef | 2010-01-16 00:51:39 +0000 | [diff] [blame] | 100 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 101 | // Handle dllimport linkage. |
| 102 | if (MO.getTargetFlags() == X86II::MO_DLLIMPORT) |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 103 | GVSym = |
| 104 | P.OutContext.GetOrCreateSymbol(Twine("__imp_") + GVSym->getName()); |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 105 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 106 | if (MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY || |
| 107 | MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY_PIC_BASE) { |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 108 | MCSymbol *Sym = P.GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 109 | MachineModuleInfoImpl::StubValueTy &StubSym = |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 110 | P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(Sym); |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 111 | if (StubSym.getPointer() == 0) |
| 112 | StubSym = MachineModuleInfoImpl:: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 113 | StubValueTy(P.getSymbol(GV), !GV->hasInternalLinkage()); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 114 | } else if (MO.getTargetFlags() == X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE){ |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 115 | MCSymbol *Sym = P.GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 116 | MachineModuleInfoImpl::StubValueTy &StubSym = |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 117 | P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getHiddenGVStubEntry( |
| 118 | Sym); |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 119 | if (StubSym.getPointer() == 0) |
| 120 | StubSym = MachineModuleInfoImpl:: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 121 | StubValueTy(P.getSymbol(GV), !GV->hasInternalLinkage()); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 122 | } else if (MO.getTargetFlags() == X86II::MO_DARWIN_STUB) { |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 123 | MCSymbol *Sym = P.GetSymbolWithGlobalValueBase(GV, "$stub"); |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 124 | MachineModuleInfoImpl::StubValueTy &StubSym = |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 125 | P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getFnStubEntry(Sym); |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 126 | if (StubSym.getPointer() == 0) |
| 127 | StubSym = MachineModuleInfoImpl:: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 128 | StubValueTy(P.getSymbol(GV), !GV->hasInternalLinkage()); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 129 | } |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 130 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 131 | // If the name begins with a dollar-sign, enclose it in parens. We do this |
| 132 | // to avoid having it look like an integer immediate to the assembler. |
Chris Lattner | e6b1bef | 2010-01-16 00:51:39 +0000 | [diff] [blame] | 133 | if (GVSym->getName()[0] != '$') |
Chris Lattner | 8b5d55e | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 134 | O << *GVSym; |
| 135 | else |
| 136 | O << '(' << *GVSym << ')'; |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 137 | P.printOffset(MO.getOffset(), O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 138 | break; |
| 139 | } |
| 140 | case MachineOperand::MO_ExternalSymbol: { |
Chris Lattner | f0a401f | 2010-01-13 07:56:59 +0000 | [diff] [blame] | 141 | const MCSymbol *SymToPrint; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 142 | if (MO.getTargetFlags() == X86II::MO_DARWIN_STUB) { |
Chris Lattner | 8a38fc3 | 2010-01-16 01:00:27 +0000 | [diff] [blame] | 143 | SmallString<128> TempNameStr; |
| 144 | TempNameStr += StringRef(MO.getSymbolName()); |
| 145 | TempNameStr += StringRef("$stub"); |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 146 | |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 147 | MCSymbol *Sym = P.GetExternalSymbolSymbol(TempNameStr.str()); |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 148 | MachineModuleInfoImpl::StubValueTy &StubSym = |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 149 | P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getFnStubEntry(Sym); |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 150 | if (StubSym.getPointer() == 0) { |
Chris Lattner | 209aeca | 2010-01-13 06:38:18 +0000 | [diff] [blame] | 151 | TempNameStr.erase(TempNameStr.end()-5, TempNameStr.end()); |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 152 | StubSym = MachineModuleInfoImpl:: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 153 | StubValueTy(P.OutContext.GetOrCreateSymbol(TempNameStr.str()), |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 154 | true); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 155 | } |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 156 | SymToPrint = StubSym.getPointer(); |
Chris Lattner | f0a401f | 2010-01-13 07:56:59 +0000 | [diff] [blame] | 157 | } else { |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 158 | SymToPrint = P.GetExternalSymbolSymbol(MO.getSymbolName()); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 159 | } |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 160 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 161 | // If the name begins with a dollar-sign, enclose it in parens. We do this |
| 162 | // to avoid having it look like an integer immediate to the assembler. |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 163 | if (SymToPrint->getName()[0] != '$') |
Chris Lattner | 8b5d55e | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 164 | O << *SymToPrint; |
| 165 | else |
| 166 | O << '(' << *SymToPrint << '('; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 167 | break; |
| 168 | } |
| 169 | } |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 170 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 171 | switch (MO.getTargetFlags()) { |
| 172 | default: |
| 173 | llvm_unreachable("Unknown target flag on GV operand"); |
| 174 | case X86II::MO_NO_FLAG: // No flag. |
| 175 | break; |
| 176 | case X86II::MO_DARWIN_NONLAZY: |
| 177 | case X86II::MO_DLLIMPORT: |
| 178 | case X86II::MO_DARWIN_STUB: |
| 179 | // These affect the name of the symbol, not any suffix. |
| 180 | break; |
| 181 | case X86II::MO_GOT_ABSOLUTE_ADDRESS: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 182 | O << " + [.-" << *P.MF->getPICBaseSymbol() << ']'; |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 183 | break; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 184 | case X86II::MO_PIC_BASE_OFFSET: |
| 185 | case X86II::MO_DARWIN_NONLAZY_PIC_BASE: |
| 186 | case X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 187 | O << '-' << *P.MF->getPICBaseSymbol(); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 188 | break; |
| 189 | case X86II::MO_TLSGD: O << "@TLSGD"; break; |
Hans Wennborg | 789acfb | 2012-06-01 16:27:21 +0000 | [diff] [blame] | 190 | case X86II::MO_TLSLD: O << "@TLSLD"; break; |
| 191 | case X86II::MO_TLSLDM: O << "@TLSLDM"; break; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 192 | case X86II::MO_GOTTPOFF: O << "@GOTTPOFF"; break; |
| 193 | case X86II::MO_INDNTPOFF: O << "@INDNTPOFF"; break; |
| 194 | case X86II::MO_TPOFF: O << "@TPOFF"; break; |
Hans Wennborg | 789acfb | 2012-06-01 16:27:21 +0000 | [diff] [blame] | 195 | case X86II::MO_DTPOFF: O << "@DTPOFF"; break; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 196 | case X86II::MO_NTPOFF: O << "@NTPOFF"; break; |
Hans Wennborg | f9d0e44 | 2012-05-11 10:11:01 +0000 | [diff] [blame] | 197 | case X86II::MO_GOTNTPOFF: O << "@GOTNTPOFF"; break; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 198 | case X86II::MO_GOTPCREL: O << "@GOTPCREL"; break; |
| 199 | case X86II::MO_GOT: O << "@GOT"; break; |
| 200 | case X86II::MO_GOTOFF: O << "@GOTOFF"; break; |
| 201 | case X86II::MO_PLT: O << "@PLT"; break; |
Eric Christopher | b0e1a45 | 2010-06-03 04:07:48 +0000 | [diff] [blame] | 202 | case X86II::MO_TLVP: O << "@TLVP"; break; |
| 203 | case X86II::MO_TLVP_PIC_BASE: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 204 | O << "@TLVP" << '-' << *P.MF->getPICBaseSymbol(); |
Eric Christopher | b0e1a45 | 2010-06-03 04:07:48 +0000 | [diff] [blame] | 205 | break; |
Benjamin Kramer | 9c9e0a2 | 2013-03-30 16:21:50 +0000 | [diff] [blame] | 206 | case X86II::MO_SECREL: O << "@SECREL32"; break; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 207 | } |
| 208 | } |
| 209 | |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 210 | static void printOperand(X86AsmPrinter &P, const MachineInstr *MI, |
| 211 | unsigned OpNo, raw_ostream &O, |
| 212 | const char *Modifier = 0, unsigned AsmVariant = 0); |
| 213 | |
Chad Rosier | 38e05a9 | 2012-09-10 22:50:57 +0000 | [diff] [blame] | 214 | /// printPCRelImm - This is used to print an immediate value that ends up |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 215 | /// being encoded as a pc-relative value. These print slightly differently, for |
| 216 | /// example, a $ is not emitted. |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 217 | static void printPCRelImm(X86AsmPrinter &P, const MachineInstr *MI, |
| 218 | unsigned OpNo, raw_ostream &O) { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 219 | const MachineOperand &MO = MI->getOperand(OpNo); |
| 220 | switch (MO.getType()) { |
| 221 | default: llvm_unreachable("Unknown pcrel immediate operand"); |
Dale Johannesen | da3e05db | 2010-07-16 18:35:46 +0000 | [diff] [blame] | 222 | case MachineOperand::MO_Register: |
| 223 | // pc-relativeness was handled when computing the value in the reg. |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 224 | printOperand(P, MI, OpNo, O); |
Dale Johannesen | da3e05db | 2010-07-16 18:35:46 +0000 | [diff] [blame] | 225 | return; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 226 | case MachineOperand::MO_Immediate: |
| 227 | O << MO.getImm(); |
| 228 | return; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 229 | case MachineOperand::MO_GlobalAddress: |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 230 | printSymbolOperand(P, MO, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 231 | return; |
| 232 | } |
| 233 | } |
| 234 | |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 235 | static void printOperand(X86AsmPrinter &P, const MachineInstr *MI, |
| 236 | unsigned OpNo, raw_ostream &O, const char *Modifier, |
| 237 | unsigned AsmVariant) { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 238 | const MachineOperand &MO = MI->getOperand(OpNo); |
| 239 | switch (MO.getType()) { |
| 240 | default: llvm_unreachable("unknown operand type!"); |
| 241 | case MachineOperand::MO_Register: { |
Chad Rosier | db20a41 | 2012-09-10 21:10:49 +0000 | [diff] [blame] | 242 | // FIXME: Enumerating AsmVariant, so we can remove magic number. |
| 243 | if (AsmVariant == 0) O << '%'; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 244 | unsigned Reg = MO.getReg(); |
| 245 | if (Modifier && strncmp(Modifier, "subreg", strlen("subreg")) == 0) { |
Craig Topper | 4f1c8ca | 2012-09-30 19:49:56 +0000 | [diff] [blame] | 246 | MVT::SimpleValueType VT = (strcmp(Modifier+6,"64") == 0) ? |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 247 | MVT::i64 : ((strcmp(Modifier+6, "32") == 0) ? MVT::i32 : |
| 248 | ((strcmp(Modifier+6,"16") == 0) ? MVT::i16 : MVT::i8)); |
| 249 | Reg = getX86SubSuperRegister(Reg, VT); |
| 250 | } |
| 251 | O << X86ATTInstPrinter::getRegisterName(Reg); |
| 252 | return; |
| 253 | } |
| 254 | |
| 255 | case MachineOperand::MO_Immediate: |
Chad Rosier | 282edd7 | 2013-02-13 21:33:44 +0000 | [diff] [blame] | 256 | if (AsmVariant == 0) O << '$'; |
| 257 | O << MO.getImm(); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 258 | return; |
| 259 | |
| 260 | case MachineOperand::MO_JumpTableIndex: |
| 261 | case MachineOperand::MO_ConstantPoolIndex: |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 262 | case MachineOperand::MO_GlobalAddress: |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 263 | case MachineOperand::MO_ExternalSymbol: { |
Chad Rosier | 282edd7 | 2013-02-13 21:33:44 +0000 | [diff] [blame] | 264 | if (AsmVariant == 0) O << '$'; |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 265 | printSymbolOperand(P, MO, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 266 | break; |
| 267 | } |
| 268 | } |
| 269 | } |
| 270 | |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 271 | static void printLeaMemReference(X86AsmPrinter &P, const MachineInstr *MI, |
| 272 | unsigned Op, raw_ostream &O, |
| 273 | const char *Modifier = NULL) { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 274 | const MachineOperand &BaseReg = MI->getOperand(Op); |
| 275 | const MachineOperand &IndexReg = MI->getOperand(Op+2); |
| 276 | const MachineOperand &DispSpec = MI->getOperand(Op+3); |
| 277 | |
| 278 | // If we really don't want to print out (rip), don't. |
| 279 | bool HasBaseReg = BaseReg.getReg() != 0; |
| 280 | if (HasBaseReg && Modifier && !strcmp(Modifier, "no-rip") && |
| 281 | BaseReg.getReg() == X86::RIP) |
| 282 | HasBaseReg = false; |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 283 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 284 | // HasParenPart - True if we will print out the () part of the mem ref. |
| 285 | bool HasParenPart = IndexReg.getReg() || HasBaseReg; |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 286 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 287 | if (DispSpec.isImm()) { |
| 288 | int DispVal = DispSpec.getImm(); |
| 289 | if (DispVal || !HasParenPart) |
| 290 | O << DispVal; |
| 291 | } else { |
| 292 | assert(DispSpec.isGlobal() || DispSpec.isCPI() || |
| 293 | DispSpec.isJTI() || DispSpec.isSymbol()); |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 294 | printSymbolOperand(P, MI->getOperand(Op+3), O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 295 | } |
| 296 | |
Rafael Espindola | d606e54 | 2011-01-01 20:58:46 +0000 | [diff] [blame] | 297 | if (Modifier && strcmp(Modifier, "H") == 0) |
| 298 | O << "+8"; |
| 299 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 300 | if (HasParenPart) { |
| 301 | assert(IndexReg.getReg() != X86::ESP && |
| 302 | "X86 doesn't allow scaling by ESP"); |
| 303 | |
| 304 | O << '('; |
| 305 | if (HasBaseReg) |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 306 | printOperand(P, MI, Op, O, Modifier); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 307 | |
| 308 | if (IndexReg.getReg()) { |
| 309 | O << ','; |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 310 | printOperand(P, MI, Op+2, O, Modifier); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 311 | unsigned ScaleVal = MI->getOperand(Op+1).getImm(); |
| 312 | if (ScaleVal != 1) |
| 313 | O << ',' << ScaleVal; |
| 314 | } |
| 315 | O << ')'; |
| 316 | } |
| 317 | } |
| 318 | |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 319 | static void printMemReference(X86AsmPrinter &P, const MachineInstr *MI, |
| 320 | unsigned Op, raw_ostream &O, |
| 321 | const char *Modifier = NULL) { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 322 | assert(isMem(MI, Op) && "Invalid memory reference!"); |
| 323 | const MachineOperand &Segment = MI->getOperand(Op+4); |
| 324 | if (Segment.getReg()) { |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 325 | printOperand(P, MI, Op+4, O, Modifier); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 326 | O << ':'; |
| 327 | } |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 328 | printLeaMemReference(P, MI, Op, O, Modifier); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 329 | } |
| 330 | |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 331 | static void printIntelMemReference(X86AsmPrinter &P, const MachineInstr *MI, |
| 332 | unsigned Op, raw_ostream &O, |
| 333 | const char *Modifier = NULL, |
| 334 | unsigned AsmVariant = 1) { |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 335 | const MachineOperand &BaseReg = MI->getOperand(Op); |
| 336 | unsigned ScaleVal = MI->getOperand(Op+1).getImm(); |
| 337 | const MachineOperand &IndexReg = MI->getOperand(Op+2); |
| 338 | const MachineOperand &DispSpec = MI->getOperand(Op+3); |
| 339 | const MachineOperand &SegReg = MI->getOperand(Op+4); |
Andrew Trick | d4d1d9c | 2013-10-31 17:18:07 +0000 | [diff] [blame] | 340 | |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 341 | // If this has a segment register, print it. |
| 342 | if (SegReg.getReg()) { |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 343 | printOperand(P, MI, Op+4, O, Modifier, AsmVariant); |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 344 | O << ':'; |
| 345 | } |
Andrew Trick | d4d1d9c | 2013-10-31 17:18:07 +0000 | [diff] [blame] | 346 | |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 347 | O << '['; |
Andrew Trick | d4d1d9c | 2013-10-31 17:18:07 +0000 | [diff] [blame] | 348 | |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 349 | bool NeedPlus = false; |
| 350 | if (BaseReg.getReg()) { |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 351 | printOperand(P, MI, Op, O, Modifier, AsmVariant); |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 352 | NeedPlus = true; |
| 353 | } |
Andrew Trick | d4d1d9c | 2013-10-31 17:18:07 +0000 | [diff] [blame] | 354 | |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 355 | if (IndexReg.getReg()) { |
| 356 | if (NeedPlus) O << " + "; |
| 357 | if (ScaleVal != 1) |
| 358 | O << ScaleVal << '*'; |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 359 | printOperand(P, MI, Op+2, O, Modifier, AsmVariant); |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 360 | NeedPlus = true; |
| 361 | } |
| 362 | |
Chad Rosier | 282edd7 | 2013-02-13 21:33:44 +0000 | [diff] [blame] | 363 | if (!DispSpec.isImm()) { |
| 364 | if (NeedPlus) O << " + "; |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 365 | printOperand(P, MI, Op+3, O, Modifier, AsmVariant); |
Chad Rosier | 282edd7 | 2013-02-13 21:33:44 +0000 | [diff] [blame] | 366 | } else { |
| 367 | int64_t DispVal = DispSpec.getImm(); |
| 368 | if (DispVal || (!IndexReg.getReg() && !BaseReg.getReg())) { |
| 369 | if (NeedPlus) { |
| 370 | if (DispVal > 0) |
| 371 | O << " + "; |
| 372 | else { |
| 373 | O << " - "; |
| 374 | DispVal = -DispVal; |
| 375 | } |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 376 | } |
Chad Rosier | 282edd7 | 2013-02-13 21:33:44 +0000 | [diff] [blame] | 377 | O << DispVal; |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 378 | } |
Chad Rosier | 282edd7 | 2013-02-13 21:33:44 +0000 | [diff] [blame] | 379 | } |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 380 | O << ']'; |
| 381 | } |
| 382 | |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 383 | static bool printAsmMRegister(X86AsmPrinter &P, const MachineOperand &MO, |
| 384 | char Mode, raw_ostream &O) { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 385 | unsigned Reg = MO.getReg(); |
| 386 | switch (Mode) { |
| 387 | default: return true; // Unknown mode. |
| 388 | case 'b': // Print QImode register |
| 389 | Reg = getX86SubSuperRegister(Reg, MVT::i8); |
| 390 | break; |
| 391 | case 'h': // Print QImode high register |
| 392 | Reg = getX86SubSuperRegister(Reg, MVT::i8, true); |
| 393 | break; |
| 394 | case 'w': // Print HImode register |
| 395 | Reg = getX86SubSuperRegister(Reg, MVT::i16); |
| 396 | break; |
| 397 | case 'k': // Print SImode register |
| 398 | Reg = getX86SubSuperRegister(Reg, MVT::i32); |
| 399 | break; |
| 400 | case 'q': // Print DImode register |
Eric Christopher | a01c954 | 2013-11-12 21:47:44 +0000 | [diff] [blame] | 401 | // FIXME: gcc will actually print e instead of r for 32-bit. |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 402 | Reg = getX86SubSuperRegister(Reg, MVT::i64); |
| 403 | break; |
| 404 | } |
| 405 | |
| 406 | O << '%' << X86ATTInstPrinter::getRegisterName(Reg); |
| 407 | return false; |
| 408 | } |
| 409 | |
| 410 | /// PrintAsmOperand - Print out an operand for an inline asm expression. |
| 411 | /// |
| 412 | bool X86AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, |
| 413 | unsigned AsmVariant, |
Chris Lattner | 3bb0976 | 2010-04-04 05:29:35 +0000 | [diff] [blame] | 414 | const char *ExtraCode, raw_ostream &O) { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 415 | // Does this asm operand have a single letter operand modifier? |
| 416 | if (ExtraCode && ExtraCode[0]) { |
| 417 | if (ExtraCode[1] != 0) return true; // Unknown modifier. |
| 418 | |
| 419 | const MachineOperand &MO = MI->getOperand(OpNo); |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 420 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 421 | switch (ExtraCode[0]) { |
Jack Carter | 5e69cff | 2012-06-26 13:49:27 +0000 | [diff] [blame] | 422 | default: |
| 423 | // See if this is a generic print operand |
| 424 | return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 425 | case 'a': // This is an address. Currently only 'i' and 'r' are expected. |
| 426 | if (MO.isImm()) { |
| 427 | O << MO.getImm(); |
| 428 | return false; |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 429 | } |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 430 | if (MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isSymbol()) { |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 431 | printSymbolOperand(*this, MO, O); |
Dale Johannesen | ce65663 | 2010-07-06 23:27:00 +0000 | [diff] [blame] | 432 | if (Subtarget->isPICStyleRIPRel()) |
| 433 | O << "(%rip)"; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 434 | return false; |
| 435 | } |
| 436 | if (MO.isReg()) { |
| 437 | O << '('; |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 438 | printOperand(*this, MI, OpNo, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 439 | O << ')'; |
| 440 | return false; |
| 441 | } |
| 442 | return true; |
| 443 | |
| 444 | case 'c': // Don't print "$" before a global var name or constant. |
| 445 | if (MO.isImm()) |
| 446 | O << MO.getImm(); |
| 447 | else if (MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isSymbol()) |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 448 | printSymbolOperand(*this, MO, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 449 | else |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 450 | printOperand(*this, MI, OpNo, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 451 | return false; |
| 452 | |
| 453 | case 'A': // Print '*' before a register (it must be a register) |
| 454 | if (MO.isReg()) { |
| 455 | O << '*'; |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 456 | printOperand(*this, MI, OpNo, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 457 | return false; |
| 458 | } |
| 459 | return true; |
| 460 | |
| 461 | case 'b': // Print QImode register |
| 462 | case 'h': // Print QImode high register |
| 463 | case 'w': // Print HImode register |
| 464 | case 'k': // Print SImode register |
| 465 | case 'q': // Print DImode register |
| 466 | if (MO.isReg()) |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 467 | return printAsmMRegister(*this, MO, ExtraCode[0], O); |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 468 | printOperand(*this, MI, OpNo, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 469 | return false; |
| 470 | |
| 471 | case 'P': // This is the operand of a call, treat specially. |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 472 | printPCRelImm(*this, MI, OpNo, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 473 | return false; |
| 474 | |
| 475 | case 'n': // Negate the immediate or print a '-' before the operand. |
| 476 | // Note: this is a temporary solution. It should be handled target |
| 477 | // independently as part of the 'MC' work. |
| 478 | if (MO.isImm()) { |
| 479 | O << -MO.getImm(); |
| 480 | return false; |
| 481 | } |
| 482 | O << '-'; |
| 483 | } |
| 484 | } |
| 485 | |
Rafael Espindola | 7caa135 | 2013-11-27 07:14:26 +0000 | [diff] [blame] | 486 | printOperand(*this, MI, OpNo, O, /*Modifier*/ 0, AsmVariant); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 487 | return false; |
| 488 | } |
| 489 | |
| 490 | bool X86AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, |
| 491 | unsigned OpNo, unsigned AsmVariant, |
Chris Lattner | 3bb0976 | 2010-04-04 05:29:35 +0000 | [diff] [blame] | 492 | const char *ExtraCode, |
| 493 | raw_ostream &O) { |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 494 | if (AsmVariant) { |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 495 | printIntelMemReference(*this, MI, OpNo, O); |
Chad Rosier | 271623f | 2012-10-03 22:06:44 +0000 | [diff] [blame] | 496 | return false; |
| 497 | } |
| 498 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 499 | if (ExtraCode && ExtraCode[0]) { |
| 500 | if (ExtraCode[1] != 0) return true; // Unknown modifier. |
| 501 | |
| 502 | switch (ExtraCode[0]) { |
| 503 | default: return true; // Unknown modifier. |
| 504 | case 'b': // Print QImode register |
| 505 | case 'h': // Print QImode high register |
| 506 | case 'w': // Print HImode register |
| 507 | case 'k': // Print SImode register |
| 508 | case 'q': // Print SImode register |
| 509 | // These only apply to registers, ignore on mem. |
| 510 | break; |
Rafael Espindola | d606e54 | 2011-01-01 20:58:46 +0000 | [diff] [blame] | 511 | case 'H': |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 512 | printMemReference(*this, MI, OpNo, O, "H"); |
Rafael Espindola | d606e54 | 2011-01-01 20:58:46 +0000 | [diff] [blame] | 513 | return false; |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 514 | case 'P': // Don't print @PLT, but do print as memory. |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 515 | printMemReference(*this, MI, OpNo, O, "no-rip"); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 516 | return false; |
| 517 | } |
| 518 | } |
Rafael Espindola | e370147 | 2013-11-27 07:34:09 +0000 | [diff] [blame^] | 519 | printMemReference(*this, MI, OpNo, O); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 520 | return false; |
| 521 | } |
| 522 | |
Chris Lattner | 81fe45d | 2010-03-13 02:10:00 +0000 | [diff] [blame] | 523 | void X86AsmPrinter::EmitStartOfAsmFile(Module &M) { |
Evan Cheng | d22a4a1 | 2011-02-01 01:14:13 +0000 | [diff] [blame] | 524 | if (Subtarget->isTargetEnvMacho()) |
Chris Lattner | 81fe45d | 2010-03-13 02:10:00 +0000 | [diff] [blame] | 525 | OutStreamer.SwitchSection(getObjFileLowering().getTextSection()); |
Reid Kleckner | c1e7621 | 2013-09-17 23:18:05 +0000 | [diff] [blame] | 526 | |
Hans Wennborg | 7ddcdc8 | 2013-10-18 02:14:40 +0000 | [diff] [blame] | 527 | if (Subtarget->isTargetCOFF()) { |
Reid Kleckner | c1e7621 | 2013-09-17 23:18:05 +0000 | [diff] [blame] | 528 | // Emit an absolute @feat.00 symbol. This appears to be some kind of |
| 529 | // compiler features bitfield read by link.exe. |
| 530 | if (!Subtarget->is64Bit()) { |
| 531 | MCSymbol *S = MMI->getContext().GetOrCreateSymbol(StringRef("@feat.00")); |
| 532 | OutStreamer.BeginCOFFSymbolDef(S); |
| 533 | OutStreamer.EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_STATIC); |
| 534 | OutStreamer.EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_NULL); |
| 535 | OutStreamer.EndCOFFSymbolDef(); |
| 536 | // According to the PE-COFF spec, the LSB of this value marks the object |
| 537 | // for "registered SEH". This means that all SEH handler entry points |
| 538 | // must be registered in .sxdata. Use of any unregistered handlers will |
| 539 | // cause the process to terminate immediately. LLVM does not know how to |
| 540 | // register any SEH handlers, so its object files should be safe. |
| 541 | S->setAbsolute(); |
Reid Kleckner | 8b2ad2a | 2013-11-18 23:08:12 +0000 | [diff] [blame] | 542 | OutStreamer.EmitSymbolAttribute(S, MCSA_Global); |
Reid Kleckner | c1e7621 | 2013-09-17 23:18:05 +0000 | [diff] [blame] | 543 | OutStreamer.EmitAssignment( |
| 544 | S, MCConstantExpr::Create(int64_t(1), MMI->getContext())); |
| 545 | } |
| 546 | } |
Chris Lattner | 81fe45d | 2010-03-13 02:10:00 +0000 | [diff] [blame] | 547 | } |
| 548 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 549 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 550 | void X86AsmPrinter::EmitEndOfAsmFile(Module &M) { |
Evan Cheng | d22a4a1 | 2011-02-01 01:14:13 +0000 | [diff] [blame] | 551 | if (Subtarget->isTargetEnvMacho()) { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 552 | // All darwin targets use mach-o. |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 553 | MachineModuleInfoMachO &MMIMacho = |
| 554 | MMI->getObjFileInfo<MachineModuleInfoMachO>(); |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 555 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 556 | // Output stubs for dynamically-linked functions. |
| 557 | MachineModuleInfoMachO::SymbolListTy Stubs; |
| 558 | |
| 559 | Stubs = MMIMacho.GetFnStubList(); |
| 560 | if (!Stubs.empty()) { |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 561 | const MCSection *TheSection = |
Chris Lattner | 433d406 | 2010-04-08 20:40:11 +0000 | [diff] [blame] | 562 | OutContext.getMachOSection("__IMPORT", "__jump_table", |
| 563 | MCSectionMachO::S_SYMBOL_STUBS | |
| 564 | MCSectionMachO::S_ATTR_SELF_MODIFYING_CODE | |
| 565 | MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS, |
| 566 | 5, SectionKind::getMetadata()); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 567 | OutStreamer.SwitchSection(TheSection); |
| 568 | |
| 569 | for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { |
Chris Lattner | 3bcbdb8 | 2010-02-03 06:42:38 +0000 | [diff] [blame] | 570 | // L_foo$stub: |
| 571 | OutStreamer.EmitLabel(Stubs[i].first); |
| 572 | // .indirect_symbol _foo |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 573 | OutStreamer.EmitSymbolAttribute(Stubs[i].second.getPointer(), |
| 574 | MCSA_IndirectSymbol); |
Jeffrey Yasskin | 065c357 | 2011-08-30 20:53:29 +0000 | [diff] [blame] | 575 | // hlt; hlt; hlt; hlt; hlt hlt = 0xf4. |
| 576 | const char HltInsts[] = "\xf4\xf4\xf4\xf4\xf4"; |
Eric Christopher | e3ab3d0 | 2013-01-09 01:57:54 +0000 | [diff] [blame] | 577 | OutStreamer.EmitBytes(StringRef(HltInsts, 5)); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 578 | } |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 579 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 580 | Stubs.clear(); |
Chris Lattner | 3bcbdb8 | 2010-02-03 06:42:38 +0000 | [diff] [blame] | 581 | OutStreamer.AddBlankLine(); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 582 | } |
| 583 | |
| 584 | // Output stubs for external and common global variables. |
| 585 | Stubs = MMIMacho.GetGVStubList(); |
| 586 | if (!Stubs.empty()) { |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 587 | const MCSection *TheSection = |
Chris Lattner | 433d406 | 2010-04-08 20:40:11 +0000 | [diff] [blame] | 588 | OutContext.getMachOSection("__IMPORT", "__pointers", |
| 589 | MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS, |
| 590 | SectionKind::getMetadata()); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 591 | OutStreamer.SwitchSection(TheSection); |
| 592 | |
| 593 | for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { |
Chris Lattner | 3bcbdb8 | 2010-02-03 06:42:38 +0000 | [diff] [blame] | 594 | // L_foo$non_lazy_ptr: |
| 595 | OutStreamer.EmitLabel(Stubs[i].first); |
| 596 | // .indirect_symbol _foo |
Bill Wendling | 3d0cd82 | 2010-03-12 19:20:40 +0000 | [diff] [blame] | 597 | MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second; |
| 598 | OutStreamer.EmitSymbolAttribute(MCSym.getPointer(), |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 599 | MCSA_IndirectSymbol); |
Chris Lattner | 3bcbdb8 | 2010-02-03 06:42:38 +0000 | [diff] [blame] | 600 | // .long 0 |
Bill Wendling | 3d0cd82 | 2010-03-12 19:20:40 +0000 | [diff] [blame] | 601 | if (MCSym.getInt()) |
| 602 | // External to current translation unit. |
Eric Christopher | e3ab3d0 | 2013-01-09 01:57:54 +0000 | [diff] [blame] | 603 | OutStreamer.EmitIntValue(0, 4/*size*/); |
Bill Wendling | 3d0cd82 | 2010-03-12 19:20:40 +0000 | [diff] [blame] | 604 | else |
| 605 | // Internal to current translation unit. |
Bill Wendling | d749aef | 2010-03-31 18:48:58 +0000 | [diff] [blame] | 606 | // |
| 607 | // When we place the LSDA into the TEXT section, the type info |
| 608 | // pointers need to be indirect and pc-rel. We accomplish this by |
| 609 | // using NLPs. However, sometimes the types are local to the file. So |
| 610 | // we need to fill in the value for the NLP in those cases. |
Bill Wendling | 3d0cd82 | 2010-03-12 19:20:40 +0000 | [diff] [blame] | 611 | OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(), |
Eric Christopher | e3ab3d0 | 2013-01-09 01:57:54 +0000 | [diff] [blame] | 612 | OutContext), 4/*size*/); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 613 | } |
| 614 | Stubs.clear(); |
Chris Lattner | 3bcbdb8 | 2010-02-03 06:42:38 +0000 | [diff] [blame] | 615 | OutStreamer.AddBlankLine(); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 616 | } |
| 617 | |
| 618 | Stubs = MMIMacho.GetHiddenGVStubList(); |
| 619 | if (!Stubs.empty()) { |
| 620 | OutStreamer.SwitchSection(getObjFileLowering().getDataSection()); |
| 621 | EmitAlignment(2); |
| 622 | |
| 623 | for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { |
Chris Lattner | 3bcbdb8 | 2010-02-03 06:42:38 +0000 | [diff] [blame] | 624 | // L_foo$non_lazy_ptr: |
| 625 | OutStreamer.EmitLabel(Stubs[i].first); |
| 626 | // .long _foo |
Bill Wendling | a810bdf | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 627 | OutStreamer.EmitValue(MCSymbolRefExpr:: |
| 628 | Create(Stubs[i].second.getPointer(), |
Eric Christopher | e3ab3d0 | 2013-01-09 01:57:54 +0000 | [diff] [blame] | 629 | OutContext), 4/*size*/); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 630 | } |
| 631 | Stubs.clear(); |
Chris Lattner | 3bcbdb8 | 2010-02-03 06:42:38 +0000 | [diff] [blame] | 632 | OutStreamer.AddBlankLine(); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 633 | } |
| 634 | |
Andrew Trick | 153ebe6 | 2013-10-31 22:11:56 +0000 | [diff] [blame] | 635 | SM.serializeToStackMapSection(); |
| 636 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 637 | // Funny Darwin hack: This flag tells the linker that no global symbols |
| 638 | // contain code that falls through to other global symbols (e.g. the obvious |
| 639 | // implementation of multiple entry points). If this doesn't occur, the |
| 640 | // linker can safely perform dead code stripping. Since LLVM never |
| 641 | // generates code that does this, it is always safe to set. |
Chris Lattner | 685508c | 2010-01-23 06:39:22 +0000 | [diff] [blame] | 642 | OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols); |
Anton Korobeynikov | 49e417c | 2009-10-15 22:36:18 +0000 | [diff] [blame] | 643 | } |
| 644 | |
Chris Lattner | 64634c3 | 2010-11-12 17:24:29 +0000 | [diff] [blame] | 645 | if (Subtarget->isTargetWindows() && !Subtarget->isTargetCygMing() && |
Michael J. Spencer | 8b98bf2 | 2012-02-22 19:06:13 +0000 | [diff] [blame] | 646 | MMI->usesVAFloatArgument()) { |
Michael J. Spencer | aa19ee1 | 2010-10-23 09:06:59 +0000 | [diff] [blame] | 647 | StringRef SymbolName = Subtarget->is64Bit() ? "_fltused" : "__fltused"; |
| 648 | MCSymbol *S = MMI->getContext().GetOrCreateSymbol(SymbolName); |
Michael J. Spencer | 5e68325 | 2010-10-16 08:25:41 +0000 | [diff] [blame] | 649 | OutStreamer.EmitSymbolAttribute(S, MCSA_Global); |
| 650 | } |
| 651 | |
Evan Cheng | d22a4a1 | 2011-02-01 01:14:13 +0000 | [diff] [blame] | 652 | if (Subtarget->isTargetCOFF() && !Subtarget->isTargetEnvMacho()) { |
Anton Korobeynikov | 49e417c | 2009-10-15 22:36:18 +0000 | [diff] [blame] | 653 | X86COFFMachineModuleInfo &COFFMMI = |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 654 | MMI->getObjFileInfo<X86COFFMachineModuleInfo>(); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 655 | |
Anton Korobeynikov | 49e417c | 2009-10-15 22:36:18 +0000 | [diff] [blame] | 656 | // Emit type information for external functions |
Chris Lattner | 72afa95 | 2010-05-08 19:54:22 +0000 | [diff] [blame] | 657 | typedef X86COFFMachineModuleInfo::externals_iterator externals_iterator; |
| 658 | for (externals_iterator I = COFFMMI.externals_begin(), |
| 659 | E = COFFMMI.externals_end(); |
| 660 | I != E; ++I) { |
| 661 | OutStreamer.BeginCOFFSymbolDef(CurrentFnSym); |
Chris Lattner | 2548580 | 2010-07-14 18:14:33 +0000 | [diff] [blame] | 662 | OutStreamer.EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_EXTERNAL); |
| 663 | OutStreamer.EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION |
| 664 | << COFF::SCT_COMPLEX_TYPE_SHIFT); |
Chris Lattner | 72afa95 | 2010-05-08 19:54:22 +0000 | [diff] [blame] | 665 | OutStreamer.EndCOFFSymbolDef(); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 666 | } |
Anton Korobeynikov | 49e417c | 2009-10-15 22:36:18 +0000 | [diff] [blame] | 667 | |
Nathan Jeffords | 2760216 | 2010-05-09 05:52:28 +0000 | [diff] [blame] | 668 | // Necessary for dllexport support |
| 669 | std::vector<const MCSymbol*> DLLExportedFns, DLLExportedGlobals; |
Anton Korobeynikov | 49e417c | 2009-10-15 22:36:18 +0000 | [diff] [blame] | 670 | |
Nathan Jeffords | 2760216 | 2010-05-09 05:52:28 +0000 | [diff] [blame] | 671 | const TargetLoweringObjectFileCOFF &TLOFCOFF = |
| 672 | static_cast<const TargetLoweringObjectFileCOFF&>(getObjFileLowering()); |
Anton Korobeynikov | 49e417c | 2009-10-15 22:36:18 +0000 | [diff] [blame] | 673 | |
Nathan Jeffords | 2760216 | 2010-05-09 05:52:28 +0000 | [diff] [blame] | 674 | for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) |
| 675 | if (I->hasDLLExportLinkage()) |
Rafael Espindola | 79858aa | 2013-10-29 17:07:16 +0000 | [diff] [blame] | 676 | DLLExportedFns.push_back(getSymbol(I)); |
Anton Korobeynikov | 49e417c | 2009-10-15 22:36:18 +0000 | [diff] [blame] | 677 | |
Nathan Jeffords | 2760216 | 2010-05-09 05:52:28 +0000 | [diff] [blame] | 678 | for (Module::const_global_iterator I = M.global_begin(), |
| 679 | E = M.global_end(); I != E; ++I) |
| 680 | if (I->hasDLLExportLinkage()) |
Rafael Espindola | 79858aa | 2013-10-29 17:07:16 +0000 | [diff] [blame] | 681 | DLLExportedGlobals.push_back(getSymbol(I)); |
Anton Korobeynikov | 49e417c | 2009-10-15 22:36:18 +0000 | [diff] [blame] | 682 | |
Nathan Jeffords | 2760216 | 2010-05-09 05:52:28 +0000 | [diff] [blame] | 683 | // Output linker support code for dllexported globals on windows. |
| 684 | if (!DLLExportedGlobals.empty() || !DLLExportedFns.empty()) { |
| 685 | OutStreamer.SwitchSection(TLOFCOFF.getDrectveSection()); |
Nathan Jeffords | b19c598 | 2010-05-09 08:40:06 +0000 | [diff] [blame] | 686 | SmallString<128> name; |
| 687 | for (unsigned i = 0, e = DLLExportedGlobals.size(); i != e; ++i) { |
| 688 | if (Subtarget->isTargetWindows()) |
| 689 | name = " /EXPORT:"; |
| 690 | else |
| 691 | name = " -export:"; |
| 692 | name += DLLExportedGlobals[i]->getName(); |
| 693 | if (Subtarget->isTargetWindows()) |
| 694 | name += ",DATA"; |
| 695 | else |
| 696 | name += ",data"; |
Eric Christopher | e3ab3d0 | 2013-01-09 01:57:54 +0000 | [diff] [blame] | 697 | OutStreamer.EmitBytes(name); |
Nathan Jeffords | b19c598 | 2010-05-09 08:40:06 +0000 | [diff] [blame] | 698 | } |
Anton Korobeynikov | 49e417c | 2009-10-15 22:36:18 +0000 | [diff] [blame] | 699 | |
Nathan Jeffords | b19c598 | 2010-05-09 08:40:06 +0000 | [diff] [blame] | 700 | for (unsigned i = 0, e = DLLExportedFns.size(); i != e; ++i) { |
| 701 | if (Subtarget->isTargetWindows()) |
| 702 | name = " /EXPORT:"; |
| 703 | else |
| 704 | name = " -export:"; |
| 705 | name += DLLExportedFns[i]->getName(); |
Eric Christopher | e3ab3d0 | 2013-01-09 01:57:54 +0000 | [diff] [blame] | 706 | OutStreamer.EmitBytes(name); |
Nathan Jeffords | b19c598 | 2010-05-09 08:40:06 +0000 | [diff] [blame] | 707 | } |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 708 | } |
| 709 | } |
Anton Korobeynikov | ae4ccc1 | 2010-02-15 22:35:59 +0000 | [diff] [blame] | 710 | |
| 711 | if (Subtarget->isTargetELF()) { |
Dan Gohman | 53d4a08 | 2010-04-17 16:44:48 +0000 | [diff] [blame] | 712 | const TargetLoweringObjectFileELF &TLOFELF = |
| 713 | static_cast<const TargetLoweringObjectFileELF &>(getObjFileLowering()); |
Anton Korobeynikov | ae4ccc1 | 2010-02-15 22:35:59 +0000 | [diff] [blame] | 714 | |
| 715 | MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>(); |
| 716 | |
| 717 | // Output stubs for external and common global variables. |
| 718 | MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList(); |
| 719 | if (!Stubs.empty()) { |
| 720 | OutStreamer.SwitchSection(TLOFELF.getDataRelSection()); |
Micah Villmow | cdfe20b | 2012-10-08 16:38:25 +0000 | [diff] [blame] | 721 | const DataLayout *TD = TM.getDataLayout(); |
Anton Korobeynikov | ae4ccc1 | 2010-02-15 22:35:59 +0000 | [diff] [blame] | 722 | |
Chris Lattner | 9b13639 | 2010-04-04 05:35:04 +0000 | [diff] [blame] | 723 | for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { |
| 724 | OutStreamer.EmitLabel(Stubs[i].first); |
| 725 | OutStreamer.EmitSymbolValue(Stubs[i].second.getPointer(), |
Eric Christopher | e3ab3d0 | 2013-01-09 01:57:54 +0000 | [diff] [blame] | 726 | TD->getPointerSize()); |
Chris Lattner | 9b13639 | 2010-04-04 05:35:04 +0000 | [diff] [blame] | 727 | } |
Anton Korobeynikov | ae4ccc1 | 2010-02-15 22:35:59 +0000 | [diff] [blame] | 728 | Stubs.clear(); |
| 729 | } |
| 730 | } |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 731 | } |
| 732 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 733 | //===----------------------------------------------------------------------===// |
| 734 | // Target Registry Stuff |
| 735 | //===----------------------------------------------------------------------===// |
| 736 | |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 737 | // Force static initialization. |
Jim Grosbach | 95ede4d | 2010-09-15 01:01:45 +0000 | [diff] [blame] | 738 | extern "C" void LLVMInitializeX86AsmPrinter() { |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 739 | RegisterAsmPrinter<X86AsmPrinter> X(TheX86_32Target); |
| 740 | RegisterAsmPrinter<X86AsmPrinter> Y(TheX86_64Target); |
Chris Lattner | 5159bbaf | 2009-09-20 07:41:30 +0000 | [diff] [blame] | 741 | } |