blob: f2f53310f4036eb03229a4774729a24aa2d54c8e [file] [log] [blame]
Chris Lattner5159bbaf2009-09-20 07:41:30 +00001//===-- X86AsmPrinter.cpp - Convert X86 LLVM code to AT&T assembly --------===//
Misha Brukmanc88330a2005-04-21 23:38:14 +00002//
John Criswell482202a2003-10-20 19:43:21 +00003// The LLVM Compiler Infrastructure
4//
Chris Lattnerf3ebc3f2007-12-29 20:36:04 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Misha Brukmanc88330a2005-04-21 23:38:14 +00007//
John Criswell482202a2003-10-20 19:43:21 +00008//===----------------------------------------------------------------------===//
Chris Lattnerd92fb002002-10-25 22:55:53 +00009//
Chris Lattner5159bbaf2009-09-20 07:41:30 +000010// This file contains a printer that converts from our internal representation
Chris Lattner94a946c2010-01-28 01:02:27 +000011// of machine-dependent LLVM code to X86 machine code.
Chris Lattnerd92fb002002-10-25 22:55:53 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner5159bbaf2009-09-20 07:41:30 +000015#include "X86AsmPrinter.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000016#include "InstPrinter/X86ATTInstPrinter.h"
Chris Lattner5159bbaf2009-09-20 07:41:30 +000017#include "X86.h"
Chris Lattner5159bbaf2009-09-20 07:41:30 +000018#include "X86COFFMachineModuleInfo.h"
19#include "X86MachineFunctionInfo.h"
20#include "X86TargetMachine.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000021#include "llvm/ADT/SmallString.h"
22#include "llvm/Assembly/Writer.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000023#include "llvm/CodeGen/MachineJumpTableInfo.h"
24#include "llvm/CodeGen/MachineModuleInfoImpls.h"
25#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
Bill Wendlinge38859d2012-06-28 00:05:13 +000026#include "llvm/DebugInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000027#include "llvm/IR/CallingConv.h"
28#include "llvm/IR/DerivedTypes.h"
29#include "llvm/IR/Module.h"
30#include "llvm/IR/Type.h"
Bill Wendlingf1eae222010-03-09 00:40:17 +000031#include "llvm/MC/MCAsmInfo.h"
Chris Lattner5159bbaf2009-09-20 07:41:30 +000032#include "llvm/MC/MCContext.h"
Chris Lattner3bcbdb82010-02-03 06:42:38 +000033#include "llvm/MC/MCExpr.h"
Chris Lattner5159bbaf2009-09-20 07:41:30 +000034#include "llvm/MC/MCSectionMachO.h"
35#include "llvm/MC/MCStreamer.h"
36#include "llvm/MC/MCSymbol.h"
Chris Lattner25485802010-07-14 18:14:33 +000037#include "llvm/Support/COFF.h"
Devang Patel2bf0f3c2010-08-04 18:06:05 +000038#include "llvm/Support/Debug.h"
Chris Lattner5159bbaf2009-09-20 07:41:30 +000039#include "llvm/Support/ErrorHandling.h"
Evan Cheng2bb40352011-08-24 18:08:43 +000040#include "llvm/Support/TargetRegistry.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000041#include "llvm/Target/Mangler.h"
42#include "llvm/Target/TargetOptions.h"
Chris Lattner5159bbaf2009-09-20 07:41:30 +000043using namespace llvm;
44
Chris Lattner5159bbaf2009-09-20 07:41:30 +000045//===----------------------------------------------------------------------===//
46// Primitive Helper Functions.
47//===----------------------------------------------------------------------===//
48
Chris Lattner94a946c2010-01-28 01:02:27 +000049/// runOnMachineFunction - Emit the function body.
Chris Lattner5159bbaf2009-09-20 07:41:30 +000050///
51bool X86AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
Chris Lattner5159bbaf2009-09-20 07:41:30 +000052 SetupMachineFunction(MF);
Chris Lattner5159bbaf2009-09-20 07:41:30 +000053
Evan Chengd22a4a12011-02-01 01:14:13 +000054 if (Subtarget->isTargetCOFF() && !Subtarget->isTargetEnvMacho()) {
Chris Lattner72afa952010-05-08 19:54:22 +000055 bool Intrn = MF.getFunction()->hasInternalLinkage();
56 OutStreamer.BeginCOFFSymbolDef(CurrentFnSym);
Jim Grosbach95ede4d2010-09-15 01:01:45 +000057 OutStreamer.EmitCOFFSymbolStorageClass(Intrn ? COFF::IMAGE_SYM_CLASS_STATIC
Chris Lattner25485802010-07-14 18:14:33 +000058 : COFF::IMAGE_SYM_CLASS_EXTERNAL);
59 OutStreamer.EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION
60 << COFF::SCT_COMPLEX_TYPE_SHIFT);
Chris Lattner72afa952010-05-08 19:54:22 +000061 OutStreamer.EndCOFFSymbolDef();
Chris Lattnerc7b91152010-01-26 23:18:44 +000062 }
Anton Korobeynikovc9276df2010-02-12 15:28:40 +000063
Chris Lattnerc7b91152010-01-26 23:18:44 +000064 // Have common code print out the function header with linkage info etc.
65 EmitFunctionHeader();
Anton Korobeynikovc9276df2010-02-12 15:28:40 +000066
Chris Lattner94a946c2010-01-28 01:02:27 +000067 // Emit the rest of the function body.
68 EmitFunctionBody();
Chris Lattner5159bbaf2009-09-20 07:41:30 +000069
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 Espindola7caa1352013-11-27 07:14:26 +000077static void printSymbolOperand(X86AsmPrinter &P, const MachineOperand &MO,
78 raw_ostream &O) {
Chris Lattner5159bbaf2009-09-20 07:41:30 +000079 switch (MO.getType()) {
80 default: llvm_unreachable("unknown symbol type!");
81 case MachineOperand::MO_JumpTableIndex:
Rafael Espindola7caa1352013-11-27 07:14:26 +000082 O << *P.GetJTISymbol(MO.getIndex());
Chris Lattner5159bbaf2009-09-20 07:41:30 +000083 break;
84 case MachineOperand::MO_ConstantPoolIndex:
Rafael Espindola7caa1352013-11-27 07:14:26 +000085 O << *P.GetCPISymbol(MO.getIndex());
86 P.printOffset(MO.getOffset(), O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +000087 break;
88 case MachineOperand::MO_GlobalAddress: {
89 const GlobalValue *GV = MO.getGlobal();
Jim Grosbach95ede4d2010-09-15 01:01:45 +000090
Chris Lattner8c21ffd2010-01-18 00:59:24 +000091 MCSymbol *GVSym;
Chris Lattner5159bbaf2009-09-20 07:41:30 +000092 if (MO.getTargetFlags() == X86II::MO_DARWIN_STUB)
Rafael Espindola7caa1352013-11-27 07:14:26 +000093 GVSym = P.GetSymbolWithGlobalValueBase(GV, "$stub");
Chris Lattner5159bbaf2009-09-20 07:41:30 +000094 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 Espindola7caa1352013-11-27 07:14:26 +000097 GVSym = P.GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
Chris Lattnere6b1bef2010-01-16 00:51:39 +000098 else
Rafael Espindola7caa1352013-11-27 07:14:26 +000099 GVSym = P.getSymbol(GV);
Chris Lattnere6b1bef2010-01-16 00:51:39 +0000100
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000101 // Handle dllimport linkage.
102 if (MO.getTargetFlags() == X86II::MO_DLLIMPORT)
Rafael Espindola7caa1352013-11-27 07:14:26 +0000103 GVSym =
104 P.OutContext.GetOrCreateSymbol(Twine("__imp_") + GVSym->getName());
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000105
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000106 if (MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY ||
107 MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY_PIC_BASE) {
Rafael Espindola7caa1352013-11-27 07:14:26 +0000108 MCSymbol *Sym = P.GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000109 MachineModuleInfoImpl::StubValueTy &StubSym =
Rafael Espindola7caa1352013-11-27 07:14:26 +0000110 P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(Sym);
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000111 if (StubSym.getPointer() == 0)
112 StubSym = MachineModuleInfoImpl::
Rafael Espindola7caa1352013-11-27 07:14:26 +0000113 StubValueTy(P.getSymbol(GV), !GV->hasInternalLinkage());
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000114 } else if (MO.getTargetFlags() == X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE){
Rafael Espindola7caa1352013-11-27 07:14:26 +0000115 MCSymbol *Sym = P.GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000116 MachineModuleInfoImpl::StubValueTy &StubSym =
Rafael Espindola7caa1352013-11-27 07:14:26 +0000117 P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getHiddenGVStubEntry(
118 Sym);
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000119 if (StubSym.getPointer() == 0)
120 StubSym = MachineModuleInfoImpl::
Rafael Espindola7caa1352013-11-27 07:14:26 +0000121 StubValueTy(P.getSymbol(GV), !GV->hasInternalLinkage());
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000122 } else if (MO.getTargetFlags() == X86II::MO_DARWIN_STUB) {
Rafael Espindola7caa1352013-11-27 07:14:26 +0000123 MCSymbol *Sym = P.GetSymbolWithGlobalValueBase(GV, "$stub");
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000124 MachineModuleInfoImpl::StubValueTy &StubSym =
Rafael Espindola7caa1352013-11-27 07:14:26 +0000125 P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getFnStubEntry(Sym);
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000126 if (StubSym.getPointer() == 0)
127 StubSym = MachineModuleInfoImpl::
Rafael Espindola7caa1352013-11-27 07:14:26 +0000128 StubValueTy(P.getSymbol(GV), !GV->hasInternalLinkage());
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000129 }
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000130
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000131 // 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 Lattnere6b1bef2010-01-16 00:51:39 +0000133 if (GVSym->getName()[0] != '$')
Chris Lattner8b5d55e2010-01-17 21:43:43 +0000134 O << *GVSym;
135 else
136 O << '(' << *GVSym << ')';
Rafael Espindola7caa1352013-11-27 07:14:26 +0000137 P.printOffset(MO.getOffset(), O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000138 break;
139 }
140 case MachineOperand::MO_ExternalSymbol: {
Chris Lattnerf0a401f2010-01-13 07:56:59 +0000141 const MCSymbol *SymToPrint;
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000142 if (MO.getTargetFlags() == X86II::MO_DARWIN_STUB) {
Chris Lattner8a38fc32010-01-16 01:00:27 +0000143 SmallString<128> TempNameStr;
144 TempNameStr += StringRef(MO.getSymbolName());
145 TempNameStr += StringRef("$stub");
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000146
Rafael Espindola7caa1352013-11-27 07:14:26 +0000147 MCSymbol *Sym = P.GetExternalSymbolSymbol(TempNameStr.str());
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000148 MachineModuleInfoImpl::StubValueTy &StubSym =
Rafael Espindola7caa1352013-11-27 07:14:26 +0000149 P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getFnStubEntry(Sym);
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000150 if (StubSym.getPointer() == 0) {
Chris Lattner209aeca2010-01-13 06:38:18 +0000151 TempNameStr.erase(TempNameStr.end()-5, TempNameStr.end());
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000152 StubSym = MachineModuleInfoImpl::
Rafael Espindola7caa1352013-11-27 07:14:26 +0000153 StubValueTy(P.OutContext.GetOrCreateSymbol(TempNameStr.str()),
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000154 true);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000155 }
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000156 SymToPrint = StubSym.getPointer();
Chris Lattnerf0a401f2010-01-13 07:56:59 +0000157 } else {
Rafael Espindola7caa1352013-11-27 07:14:26 +0000158 SymToPrint = P.GetExternalSymbolSymbol(MO.getSymbolName());
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000159 }
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000160
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000161 // 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 Grosbach95ede4d2010-09-15 01:01:45 +0000163 if (SymToPrint->getName()[0] != '$')
Chris Lattner8b5d55e2010-01-17 21:43:43 +0000164 O << *SymToPrint;
165 else
166 O << '(' << *SymToPrint << '(';
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000167 break;
168 }
169 }
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000170
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000171 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 Espindola7caa1352013-11-27 07:14:26 +0000182 O << " + [.-" << *P.MF->getPICBaseSymbol() << ']';
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000183 break;
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000184 case X86II::MO_PIC_BASE_OFFSET:
185 case X86II::MO_DARWIN_NONLAZY_PIC_BASE:
186 case X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE:
Rafael Espindola7caa1352013-11-27 07:14:26 +0000187 O << '-' << *P.MF->getPICBaseSymbol();
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000188 break;
189 case X86II::MO_TLSGD: O << "@TLSGD"; break;
Hans Wennborg789acfb2012-06-01 16:27:21 +0000190 case X86II::MO_TLSLD: O << "@TLSLD"; break;
191 case X86II::MO_TLSLDM: O << "@TLSLDM"; break;
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000192 case X86II::MO_GOTTPOFF: O << "@GOTTPOFF"; break;
193 case X86II::MO_INDNTPOFF: O << "@INDNTPOFF"; break;
194 case X86II::MO_TPOFF: O << "@TPOFF"; break;
Hans Wennborg789acfb2012-06-01 16:27:21 +0000195 case X86II::MO_DTPOFF: O << "@DTPOFF"; break;
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000196 case X86II::MO_NTPOFF: O << "@NTPOFF"; break;
Hans Wennborgf9d0e442012-05-11 10:11:01 +0000197 case X86II::MO_GOTNTPOFF: O << "@GOTNTPOFF"; break;
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000198 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 Christopherb0e1a452010-06-03 04:07:48 +0000202 case X86II::MO_TLVP: O << "@TLVP"; break;
203 case X86II::MO_TLVP_PIC_BASE:
Rafael Espindola7caa1352013-11-27 07:14:26 +0000204 O << "@TLVP" << '-' << *P.MF->getPICBaseSymbol();
Eric Christopherb0e1a452010-06-03 04:07:48 +0000205 break;
Benjamin Kramer9c9e0a22013-03-30 16:21:50 +0000206 case X86II::MO_SECREL: O << "@SECREL32"; break;
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000207 }
208}
209
Rafael Espindola7caa1352013-11-27 07:14:26 +0000210static void printOperand(X86AsmPrinter &P, const MachineInstr *MI,
211 unsigned OpNo, raw_ostream &O,
212 const char *Modifier = 0, unsigned AsmVariant = 0);
213
Chad Rosier38e05a92012-09-10 22:50:57 +0000214/// printPCRelImm - This is used to print an immediate value that ends up
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000215/// being encoded as a pc-relative value. These print slightly differently, for
216/// example, a $ is not emitted.
Rafael Espindola7caa1352013-11-27 07:14:26 +0000217static void printPCRelImm(X86AsmPrinter &P, const MachineInstr *MI,
218 unsigned OpNo, raw_ostream &O) {
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000219 const MachineOperand &MO = MI->getOperand(OpNo);
220 switch (MO.getType()) {
221 default: llvm_unreachable("Unknown pcrel immediate operand");
Dale Johannesenda3e05db2010-07-16 18:35:46 +0000222 case MachineOperand::MO_Register:
223 // pc-relativeness was handled when computing the value in the reg.
Rafael Espindola7caa1352013-11-27 07:14:26 +0000224 printOperand(P, MI, OpNo, O);
Dale Johannesenda3e05db2010-07-16 18:35:46 +0000225 return;
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000226 case MachineOperand::MO_Immediate:
227 O << MO.getImm();
228 return;
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000229 case MachineOperand::MO_GlobalAddress:
Rafael Espindola7caa1352013-11-27 07:14:26 +0000230 printSymbolOperand(P, MO, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000231 return;
232 }
233}
234
Rafael Espindola7caa1352013-11-27 07:14:26 +0000235static void printOperand(X86AsmPrinter &P, const MachineInstr *MI,
236 unsigned OpNo, raw_ostream &O, const char *Modifier,
237 unsigned AsmVariant) {
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000238 const MachineOperand &MO = MI->getOperand(OpNo);
239 switch (MO.getType()) {
240 default: llvm_unreachable("unknown operand type!");
241 case MachineOperand::MO_Register: {
Chad Rosierdb20a412012-09-10 21:10:49 +0000242 // FIXME: Enumerating AsmVariant, so we can remove magic number.
243 if (AsmVariant == 0) O << '%';
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000244 unsigned Reg = MO.getReg();
245 if (Modifier && strncmp(Modifier, "subreg", strlen("subreg")) == 0) {
Craig Topper4f1c8ca2012-09-30 19:49:56 +0000246 MVT::SimpleValueType VT = (strcmp(Modifier+6,"64") == 0) ?
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000247 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 Rosier282edd72013-02-13 21:33:44 +0000256 if (AsmVariant == 0) O << '$';
257 O << MO.getImm();
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000258 return;
259
260 case MachineOperand::MO_JumpTableIndex:
261 case MachineOperand::MO_ConstantPoolIndex:
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000262 case MachineOperand::MO_GlobalAddress:
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000263 case MachineOperand::MO_ExternalSymbol: {
Chad Rosier282edd72013-02-13 21:33:44 +0000264 if (AsmVariant == 0) O << '$';
Rafael Espindola7caa1352013-11-27 07:14:26 +0000265 printSymbolOperand(P, MO, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000266 break;
267 }
268 }
269}
270
Rafael Espindolae3701472013-11-27 07:34:09 +0000271static void printLeaMemReference(X86AsmPrinter &P, const MachineInstr *MI,
272 unsigned Op, raw_ostream &O,
273 const char *Modifier = NULL) {
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000274 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 Grosbach95ede4d2010-09-15 01:01:45 +0000283
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000284 // HasParenPart - True if we will print out the () part of the mem ref.
285 bool HasParenPart = IndexReg.getReg() || HasBaseReg;
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000286
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000287 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 Espindolae3701472013-11-27 07:34:09 +0000294 printSymbolOperand(P, MI->getOperand(Op+3), O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000295 }
296
Rafael Espindolad606e542011-01-01 20:58:46 +0000297 if (Modifier && strcmp(Modifier, "H") == 0)
298 O << "+8";
299
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000300 if (HasParenPart) {
301 assert(IndexReg.getReg() != X86::ESP &&
302 "X86 doesn't allow scaling by ESP");
303
304 O << '(';
305 if (HasBaseReg)
Rafael Espindolae3701472013-11-27 07:34:09 +0000306 printOperand(P, MI, Op, O, Modifier);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000307
308 if (IndexReg.getReg()) {
309 O << ',';
Rafael Espindolae3701472013-11-27 07:34:09 +0000310 printOperand(P, MI, Op+2, O, Modifier);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000311 unsigned ScaleVal = MI->getOperand(Op+1).getImm();
312 if (ScaleVal != 1)
313 O << ',' << ScaleVal;
314 }
315 O << ')';
316 }
317}
318
Rafael Espindolae3701472013-11-27 07:34:09 +0000319static void printMemReference(X86AsmPrinter &P, const MachineInstr *MI,
320 unsigned Op, raw_ostream &O,
321 const char *Modifier = NULL) {
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000322 assert(isMem(MI, Op) && "Invalid memory reference!");
323 const MachineOperand &Segment = MI->getOperand(Op+4);
324 if (Segment.getReg()) {
Rafael Espindolae3701472013-11-27 07:34:09 +0000325 printOperand(P, MI, Op+4, O, Modifier);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000326 O << ':';
327 }
Rafael Espindolae3701472013-11-27 07:34:09 +0000328 printLeaMemReference(P, MI, Op, O, Modifier);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000329}
330
Rafael Espindolae3701472013-11-27 07:34:09 +0000331static void printIntelMemReference(X86AsmPrinter &P, const MachineInstr *MI,
332 unsigned Op, raw_ostream &O,
333 const char *Modifier = NULL,
334 unsigned AsmVariant = 1) {
Chad Rosier271623f2012-10-03 22:06:44 +0000335 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 Trickd4d1d9c2013-10-31 17:18:07 +0000340
Chad Rosier271623f2012-10-03 22:06:44 +0000341 // If this has a segment register, print it.
342 if (SegReg.getReg()) {
Rafael Espindolae3701472013-11-27 07:34:09 +0000343 printOperand(P, MI, Op+4, O, Modifier, AsmVariant);
Chad Rosier271623f2012-10-03 22:06:44 +0000344 O << ':';
345 }
Andrew Trickd4d1d9c2013-10-31 17:18:07 +0000346
Chad Rosier271623f2012-10-03 22:06:44 +0000347 O << '[';
Andrew Trickd4d1d9c2013-10-31 17:18:07 +0000348
Chad Rosier271623f2012-10-03 22:06:44 +0000349 bool NeedPlus = false;
350 if (BaseReg.getReg()) {
Rafael Espindolae3701472013-11-27 07:34:09 +0000351 printOperand(P, MI, Op, O, Modifier, AsmVariant);
Chad Rosier271623f2012-10-03 22:06:44 +0000352 NeedPlus = true;
353 }
Andrew Trickd4d1d9c2013-10-31 17:18:07 +0000354
Chad Rosier271623f2012-10-03 22:06:44 +0000355 if (IndexReg.getReg()) {
356 if (NeedPlus) O << " + ";
357 if (ScaleVal != 1)
358 O << ScaleVal << '*';
Rafael Espindolae3701472013-11-27 07:34:09 +0000359 printOperand(P, MI, Op+2, O, Modifier, AsmVariant);
Chad Rosier271623f2012-10-03 22:06:44 +0000360 NeedPlus = true;
361 }
362
Chad Rosier282edd72013-02-13 21:33:44 +0000363 if (!DispSpec.isImm()) {
364 if (NeedPlus) O << " + ";
Rafael Espindolae3701472013-11-27 07:34:09 +0000365 printOperand(P, MI, Op+3, O, Modifier, AsmVariant);
Chad Rosier282edd72013-02-13 21:33:44 +0000366 } 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 Rosier271623f2012-10-03 22:06:44 +0000376 }
Chad Rosier282edd72013-02-13 21:33:44 +0000377 O << DispVal;
Chad Rosier271623f2012-10-03 22:06:44 +0000378 }
Chad Rosier282edd72013-02-13 21:33:44 +0000379 }
Chad Rosier271623f2012-10-03 22:06:44 +0000380 O << ']';
381}
382
Rafael Espindolae3701472013-11-27 07:34:09 +0000383static bool printAsmMRegister(X86AsmPrinter &P, const MachineOperand &MO,
384 char Mode, raw_ostream &O) {
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000385 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 Christophera01c9542013-11-12 21:47:44 +0000401 // FIXME: gcc will actually print e instead of r for 32-bit.
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000402 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///
412bool X86AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
413 unsigned AsmVariant,
Chris Lattner3bb09762010-04-04 05:29:35 +0000414 const char *ExtraCode, raw_ostream &O) {
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000415 // 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 Grosbach95ede4d2010-09-15 01:01:45 +0000420
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000421 switch (ExtraCode[0]) {
Jack Carter5e69cff2012-06-26 13:49:27 +0000422 default:
423 // See if this is a generic print operand
424 return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000425 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 Grosbach95ede4d2010-09-15 01:01:45 +0000429 }
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000430 if (MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isSymbol()) {
Rafael Espindola7caa1352013-11-27 07:14:26 +0000431 printSymbolOperand(*this, MO, O);
Dale Johannesence656632010-07-06 23:27:00 +0000432 if (Subtarget->isPICStyleRIPRel())
433 O << "(%rip)";
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000434 return false;
435 }
436 if (MO.isReg()) {
437 O << '(';
Rafael Espindola7caa1352013-11-27 07:14:26 +0000438 printOperand(*this, MI, OpNo, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000439 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 Espindola7caa1352013-11-27 07:14:26 +0000448 printSymbolOperand(*this, MO, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000449 else
Rafael Espindola7caa1352013-11-27 07:14:26 +0000450 printOperand(*this, MI, OpNo, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000451 return false;
452
453 case 'A': // Print '*' before a register (it must be a register)
454 if (MO.isReg()) {
455 O << '*';
Rafael Espindola7caa1352013-11-27 07:14:26 +0000456 printOperand(*this, MI, OpNo, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000457 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 Espindolae3701472013-11-27 07:34:09 +0000467 return printAsmMRegister(*this, MO, ExtraCode[0], O);
Rafael Espindola7caa1352013-11-27 07:14:26 +0000468 printOperand(*this, MI, OpNo, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000469 return false;
470
471 case 'P': // This is the operand of a call, treat specially.
Rafael Espindola7caa1352013-11-27 07:14:26 +0000472 printPCRelImm(*this, MI, OpNo, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000473 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 Espindola7caa1352013-11-27 07:14:26 +0000486 printOperand(*this, MI, OpNo, O, /*Modifier*/ 0, AsmVariant);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000487 return false;
488}
489
490bool X86AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
491 unsigned OpNo, unsigned AsmVariant,
Chris Lattner3bb09762010-04-04 05:29:35 +0000492 const char *ExtraCode,
493 raw_ostream &O) {
Chad Rosier271623f2012-10-03 22:06:44 +0000494 if (AsmVariant) {
Rafael Espindolae3701472013-11-27 07:34:09 +0000495 printIntelMemReference(*this, MI, OpNo, O);
Chad Rosier271623f2012-10-03 22:06:44 +0000496 return false;
497 }
498
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000499 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 Espindolad606e542011-01-01 20:58:46 +0000511 case 'H':
Rafael Espindolae3701472013-11-27 07:34:09 +0000512 printMemReference(*this, MI, OpNo, O, "H");
Rafael Espindolad606e542011-01-01 20:58:46 +0000513 return false;
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000514 case 'P': // Don't print @PLT, but do print as memory.
Rafael Espindolae3701472013-11-27 07:34:09 +0000515 printMemReference(*this, MI, OpNo, O, "no-rip");
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000516 return false;
517 }
518 }
Rafael Espindolae3701472013-11-27 07:34:09 +0000519 printMemReference(*this, MI, OpNo, O);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000520 return false;
521}
522
Chris Lattner81fe45d2010-03-13 02:10:00 +0000523void X86AsmPrinter::EmitStartOfAsmFile(Module &M) {
Evan Chengd22a4a12011-02-01 01:14:13 +0000524 if (Subtarget->isTargetEnvMacho())
Chris Lattner81fe45d2010-03-13 02:10:00 +0000525 OutStreamer.SwitchSection(getObjFileLowering().getTextSection());
Reid Klecknerc1e76212013-09-17 23:18:05 +0000526
Hans Wennborg7ddcdc82013-10-18 02:14:40 +0000527 if (Subtarget->isTargetCOFF()) {
Reid Klecknerc1e76212013-09-17 23:18:05 +0000528 // 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 Kleckner8b2ad2a2013-11-18 23:08:12 +0000542 OutStreamer.EmitSymbolAttribute(S, MCSA_Global);
Reid Klecknerc1e76212013-09-17 23:18:05 +0000543 OutStreamer.EmitAssignment(
544 S, MCConstantExpr::Create(int64_t(1), MMI->getContext()));
545 }
546 }
Chris Lattner81fe45d2010-03-13 02:10:00 +0000547}
548
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000549
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000550void X86AsmPrinter::EmitEndOfAsmFile(Module &M) {
Evan Chengd22a4a12011-02-01 01:14:13 +0000551 if (Subtarget->isTargetEnvMacho()) {
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000552 // All darwin targets use mach-o.
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000553 MachineModuleInfoMachO &MMIMacho =
554 MMI->getObjFileInfo<MachineModuleInfoMachO>();
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000555
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000556 // Output stubs for dynamically-linked functions.
557 MachineModuleInfoMachO::SymbolListTy Stubs;
558
559 Stubs = MMIMacho.GetFnStubList();
560 if (!Stubs.empty()) {
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000561 const MCSection *TheSection =
Chris Lattner433d4062010-04-08 20:40:11 +0000562 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 Lattner5159bbaf2009-09-20 07:41:30 +0000567 OutStreamer.SwitchSection(TheSection);
568
569 for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
Chris Lattner3bcbdb82010-02-03 06:42:38 +0000570 // L_foo$stub:
571 OutStreamer.EmitLabel(Stubs[i].first);
572 // .indirect_symbol _foo
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000573 OutStreamer.EmitSymbolAttribute(Stubs[i].second.getPointer(),
574 MCSA_IndirectSymbol);
Jeffrey Yasskin065c3572011-08-30 20:53:29 +0000575 // hlt; hlt; hlt; hlt; hlt hlt = 0xf4.
576 const char HltInsts[] = "\xf4\xf4\xf4\xf4\xf4";
Eric Christophere3ab3d02013-01-09 01:57:54 +0000577 OutStreamer.EmitBytes(StringRef(HltInsts, 5));
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000578 }
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000579
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000580 Stubs.clear();
Chris Lattner3bcbdb82010-02-03 06:42:38 +0000581 OutStreamer.AddBlankLine();
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000582 }
583
584 // Output stubs for external and common global variables.
585 Stubs = MMIMacho.GetGVStubList();
586 if (!Stubs.empty()) {
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000587 const MCSection *TheSection =
Chris Lattner433d4062010-04-08 20:40:11 +0000588 OutContext.getMachOSection("__IMPORT", "__pointers",
589 MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
590 SectionKind::getMetadata());
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000591 OutStreamer.SwitchSection(TheSection);
592
593 for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
Chris Lattner3bcbdb82010-02-03 06:42:38 +0000594 // L_foo$non_lazy_ptr:
595 OutStreamer.EmitLabel(Stubs[i].first);
596 // .indirect_symbol _foo
Bill Wendling3d0cd822010-03-12 19:20:40 +0000597 MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
598 OutStreamer.EmitSymbolAttribute(MCSym.getPointer(),
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000599 MCSA_IndirectSymbol);
Chris Lattner3bcbdb82010-02-03 06:42:38 +0000600 // .long 0
Bill Wendling3d0cd822010-03-12 19:20:40 +0000601 if (MCSym.getInt())
602 // External to current translation unit.
Eric Christophere3ab3d02013-01-09 01:57:54 +0000603 OutStreamer.EmitIntValue(0, 4/*size*/);
Bill Wendling3d0cd822010-03-12 19:20:40 +0000604 else
605 // Internal to current translation unit.
Bill Wendlingd749aef2010-03-31 18:48:58 +0000606 //
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 Wendling3d0cd822010-03-12 19:20:40 +0000611 OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(),
Eric Christophere3ab3d02013-01-09 01:57:54 +0000612 OutContext), 4/*size*/);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000613 }
614 Stubs.clear();
Chris Lattner3bcbdb82010-02-03 06:42:38 +0000615 OutStreamer.AddBlankLine();
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000616 }
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 Lattner3bcbdb82010-02-03 06:42:38 +0000624 // L_foo$non_lazy_ptr:
625 OutStreamer.EmitLabel(Stubs[i].first);
626 // .long _foo
Bill Wendlinga810bdf2010-03-10 22:34:10 +0000627 OutStreamer.EmitValue(MCSymbolRefExpr::
628 Create(Stubs[i].second.getPointer(),
Eric Christophere3ab3d02013-01-09 01:57:54 +0000629 OutContext), 4/*size*/);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000630 }
631 Stubs.clear();
Chris Lattner3bcbdb82010-02-03 06:42:38 +0000632 OutStreamer.AddBlankLine();
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000633 }
634
Andrew Trick153ebe62013-10-31 22:11:56 +0000635 SM.serializeToStackMapSection();
636
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000637 // 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 Lattner685508c2010-01-23 06:39:22 +0000642 OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
Anton Korobeynikov49e417c2009-10-15 22:36:18 +0000643 }
644
Chris Lattner64634c32010-11-12 17:24:29 +0000645 if (Subtarget->isTargetWindows() && !Subtarget->isTargetCygMing() &&
Michael J. Spencer8b98bf22012-02-22 19:06:13 +0000646 MMI->usesVAFloatArgument()) {
Michael J. Spenceraa19ee12010-10-23 09:06:59 +0000647 StringRef SymbolName = Subtarget->is64Bit() ? "_fltused" : "__fltused";
648 MCSymbol *S = MMI->getContext().GetOrCreateSymbol(SymbolName);
Michael J. Spencer5e683252010-10-16 08:25:41 +0000649 OutStreamer.EmitSymbolAttribute(S, MCSA_Global);
650 }
651
Evan Chengd22a4a12011-02-01 01:14:13 +0000652 if (Subtarget->isTargetCOFF() && !Subtarget->isTargetEnvMacho()) {
Anton Korobeynikov49e417c2009-10-15 22:36:18 +0000653 X86COFFMachineModuleInfo &COFFMMI =
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000654 MMI->getObjFileInfo<X86COFFMachineModuleInfo>();
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000655
Anton Korobeynikov49e417c2009-10-15 22:36:18 +0000656 // Emit type information for external functions
Chris Lattner72afa952010-05-08 19:54:22 +0000657 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 Lattner25485802010-07-14 18:14:33 +0000662 OutStreamer.EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_EXTERNAL);
663 OutStreamer.EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION
664 << COFF::SCT_COMPLEX_TYPE_SHIFT);
Chris Lattner72afa952010-05-08 19:54:22 +0000665 OutStreamer.EndCOFFSymbolDef();
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000666 }
Anton Korobeynikov49e417c2009-10-15 22:36:18 +0000667
Nathan Jeffords27602162010-05-09 05:52:28 +0000668 // Necessary for dllexport support
669 std::vector<const MCSymbol*> DLLExportedFns, DLLExportedGlobals;
Anton Korobeynikov49e417c2009-10-15 22:36:18 +0000670
Nathan Jeffords27602162010-05-09 05:52:28 +0000671 const TargetLoweringObjectFileCOFF &TLOFCOFF =
672 static_cast<const TargetLoweringObjectFileCOFF&>(getObjFileLowering());
Anton Korobeynikov49e417c2009-10-15 22:36:18 +0000673
Nathan Jeffords27602162010-05-09 05:52:28 +0000674 for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I)
675 if (I->hasDLLExportLinkage())
Rafael Espindola79858aa2013-10-29 17:07:16 +0000676 DLLExportedFns.push_back(getSymbol(I));
Anton Korobeynikov49e417c2009-10-15 22:36:18 +0000677
Nathan Jeffords27602162010-05-09 05:52:28 +0000678 for (Module::const_global_iterator I = M.global_begin(),
679 E = M.global_end(); I != E; ++I)
680 if (I->hasDLLExportLinkage())
Rafael Espindola79858aa2013-10-29 17:07:16 +0000681 DLLExportedGlobals.push_back(getSymbol(I));
Anton Korobeynikov49e417c2009-10-15 22:36:18 +0000682
Nathan Jeffords27602162010-05-09 05:52:28 +0000683 // Output linker support code for dllexported globals on windows.
684 if (!DLLExportedGlobals.empty() || !DLLExportedFns.empty()) {
685 OutStreamer.SwitchSection(TLOFCOFF.getDrectveSection());
Nathan Jeffordsb19c5982010-05-09 08:40:06 +0000686 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 Christophere3ab3d02013-01-09 01:57:54 +0000697 OutStreamer.EmitBytes(name);
Nathan Jeffordsb19c5982010-05-09 08:40:06 +0000698 }
Anton Korobeynikov49e417c2009-10-15 22:36:18 +0000699
Nathan Jeffordsb19c5982010-05-09 08:40:06 +0000700 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 Christophere3ab3d02013-01-09 01:57:54 +0000706 OutStreamer.EmitBytes(name);
Nathan Jeffordsb19c5982010-05-09 08:40:06 +0000707 }
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000708 }
709 }
Anton Korobeynikovae4ccc12010-02-15 22:35:59 +0000710
711 if (Subtarget->isTargetELF()) {
Dan Gohman53d4a082010-04-17 16:44:48 +0000712 const TargetLoweringObjectFileELF &TLOFELF =
713 static_cast<const TargetLoweringObjectFileELF &>(getObjFileLowering());
Anton Korobeynikovae4ccc12010-02-15 22:35:59 +0000714
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 Villmowcdfe20b2012-10-08 16:38:25 +0000721 const DataLayout *TD = TM.getDataLayout();
Anton Korobeynikovae4ccc12010-02-15 22:35:59 +0000722
Chris Lattner9b136392010-04-04 05:35:04 +0000723 for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
724 OutStreamer.EmitLabel(Stubs[i].first);
725 OutStreamer.EmitSymbolValue(Stubs[i].second.getPointer(),
Eric Christophere3ab3d02013-01-09 01:57:54 +0000726 TD->getPointerSize());
Chris Lattner9b136392010-04-04 05:35:04 +0000727 }
Anton Korobeynikovae4ccc12010-02-15 22:35:59 +0000728 Stubs.clear();
729 }
730 }
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000731}
732
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000733//===----------------------------------------------------------------------===//
734// Target Registry Stuff
735//===----------------------------------------------------------------------===//
736
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000737// Force static initialization.
Jim Grosbach95ede4d2010-09-15 01:01:45 +0000738extern "C" void LLVMInitializeX86AsmPrinter() {
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000739 RegisterAsmPrinter<X86AsmPrinter> X(TheX86_32Target);
740 RegisterAsmPrinter<X86AsmPrinter> Y(TheX86_64Target);
Chris Lattner5159bbaf2009-09-20 07:41:30 +0000741}