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