1 //===-- PPCAsmPrinter.cpp - Print machine instrs to PowerPC 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 PowerPC assembly language. This printer is
12 // the output mechanism used by `llc'.
13 //
14 // Documentation at http://developer.apple.com/documentation/DeveloperTools/
15 // Reference/Assembler/ASMIntroduction/chapter_1_section_1.html
16 //
17 //===----------------------------------------------------------------------===//
18 
19 #define DEBUG_TYPE "asmprinter"
20 #include "PPC.h"
21 #include "InstPrinter/PPCInstPrinter.h"
22 #include "MCTargetDesc/PPCPredicates.h"
23 #include "MCTargetDesc/PPCMCExpr.h"
24 #include "PPCSubtarget.h"
25 #include "PPCTargetMachine.h"
26 #include "PPCTargetStreamer.h"
27 #include "llvm/ADT/MapVector.h"
28 #include "llvm/ADT/SmallString.h"
29 #include "llvm/ADT/StringExtras.h"
30 #include "llvm/Assembly/Writer.h"
31 #include "llvm/CodeGen/AsmPrinter.h"
32 #include "llvm/CodeGen/MachineFunctionPass.h"
33 #include "llvm/CodeGen/MachineInstr.h"
34 #include "llvm/CodeGen/MachineInstrBuilder.h"
35 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
36 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
37 #include "llvm/DebugInfo.h"
38 #include "llvm/IR/Constants.h"
39 #include "llvm/IR/DerivedTypes.h"
40 #include "llvm/IR/Module.h"
41 #include "llvm/MC/MCAsmInfo.h"
42 #include "llvm/MC/MCContext.h"
43 #include "llvm/MC/MCExpr.h"
44 #include "llvm/MC/MCInst.h"
45 #include "llvm/MC/MCInstBuilder.h"
46 #include "llvm/MC/MCSectionELF.h"
47 #include "llvm/MC/MCSectionMachO.h"
48 #include "llvm/MC/MCStreamer.h"
49 #include "llvm/MC/MCSymbol.h"
50 #include "llvm/Support/CommandLine.h"
51 #include "llvm/Support/Debug.h"
52 #include "llvm/Support/ELF.h"
53 #include "llvm/Support/ErrorHandling.h"
54 #include "llvm/Support/MathExtras.h"
55 #include "llvm/Support/TargetRegistry.h"
56 #include "llvm/Support/raw_ostream.h"
57 #include "llvm/Target/Mangler.h"
58 #include "llvm/Target/TargetInstrInfo.h"
59 #include "llvm/Target/TargetOptions.h"
60 #include "llvm/Target/TargetRegisterInfo.h"
61 using namespace llvm;
62 
63 namespace {
64   class PPCAsmPrinter : public AsmPrinter {
65   protected:
66     MapVector<MCSymbol*, MCSymbol*> TOC;
67     const PPCSubtarget &Subtarget;
68     uint64_t TOCLabelID;
69   public:
70     explicit PPCAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
71       : AsmPrinter(TM, Streamer),
72         Subtarget(TM.getSubtarget<PPCSubtarget>()), TOCLabelID(0) {}
73 
74     virtual const char *getPassName() const {
75       return "PowerPC Assembly Printer";
76     }
77 
78     MCSymbol *lookUpOrCreateTOCEntry(MCSymbol *Sym);
79 
80     virtual void EmitInstruction(const MachineInstr *MI);
81 
82     void printOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
83 
84     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
85                          unsigned AsmVariant, const char *ExtraCode,
86                          raw_ostream &O);
87     bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
88                                unsigned AsmVariant, const char *ExtraCode,
89                                raw_ostream &O);
90   };
91 
92   /// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux
93   class PPCLinuxAsmPrinter : public PPCAsmPrinter {
94   public:
95     explicit PPCLinuxAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
96       : PPCAsmPrinter(TM, Streamer) {}
97 
98     virtual const char *getPassName() const {
99       return "Linux PPC Assembly Printer";
100     }
101 
102     bool doFinalization(Module &M);
103 
104     virtual void EmitFunctionEntryLabel();
105 
106     void EmitFunctionBodyEnd();
107   };
108 
109   /// PPCDarwinAsmPrinter - PowerPC assembly printer, customized for Darwin/Mac
110   /// OS X
111   class PPCDarwinAsmPrinter : public PPCAsmPrinter {
112   public:
113     explicit PPCDarwinAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
114       : PPCAsmPrinter(TM, Streamer) {}
115 
116     virtual const char *getPassName() const {
117       return "Darwin PPC Assembly Printer";
118     }
119 
120     bool doFinalization(Module &M);
121     void EmitStartOfAsmFile(Module &M);
122 
123     void EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs);
124   };
125 } // end of anonymous namespace
126 
127 /// stripRegisterPrefix - This method strips the character prefix from a
128 /// register name so that only the number is left.  Used by for linux asm.
129 static const char *stripRegisterPrefix(const char *RegName) {
130   switch (RegName[0]) {
131     case 'r':
132     case 'f':
133     case 'v': return RegName + 1;
134     case 'c': if (RegName[1] == 'r') return RegName + 2;
135   }
136 
137   return RegName;
138 }
139 
140 void PPCAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
141                                  raw_ostream &O) {
142   const MachineOperand &MO = MI->getOperand(OpNo);
143 
144   switch (MO.getType()) {
145   case MachineOperand::MO_Register: {
146     const char *RegName = PPCInstPrinter::getRegisterName(MO.getReg());
147     // Linux assembler (Others?) does not take register mnemonics.
148     // FIXME - What about special registers used in mfspr/mtspr?
149     if (!Subtarget.isDarwin()) RegName = stripRegisterPrefix(RegName);
150     O << RegName;
151     return;
152   }
153   case MachineOperand::MO_Immediate:
154     O << MO.getImm();
155     return;
156 
157   case MachineOperand::MO_MachineBasicBlock:
158     O << *MO.getMBB()->getSymbol();
159     return;
160   case MachineOperand::MO_ConstantPoolIndex:
161     O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber()
162       << '_' << MO.getIndex();
163     return;
164   case MachineOperand::MO_BlockAddress:
165     O << *GetBlockAddressSymbol(MO.getBlockAddress());
166     return;
167   case MachineOperand::MO_GlobalAddress: {
168     // Computing the address of a global symbol, not calling it.
169     const GlobalValue *GV = MO.getGlobal();
170     MCSymbol *SymToPrint;
171 
172     // External or weakly linked global variables need non-lazily-resolved stubs
173     if (TM.getRelocationModel() != Reloc::Static &&
174         (GV->isDeclaration() || GV->isWeakForLinker())) {
175       if (!GV->hasHiddenVisibility()) {
176         SymToPrint = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
177         MachineModuleInfoImpl::StubValueTy &StubSym =
178           MMI->getObjFileInfo<MachineModuleInfoMachO>()
179             .getGVStubEntry(SymToPrint);
180         if (StubSym.getPointer() == 0)
181           StubSym = MachineModuleInfoImpl::
182             StubValueTy(getSymbol(GV), !GV->hasInternalLinkage());
183       } else if (GV->isDeclaration() || GV->hasCommonLinkage() ||
184                  GV->hasAvailableExternallyLinkage()) {
185         SymToPrint = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
186 
187         MachineModuleInfoImpl::StubValueTy &StubSym =
188           MMI->getObjFileInfo<MachineModuleInfoMachO>().
189                     getHiddenGVStubEntry(SymToPrint);
190         if (StubSym.getPointer() == 0)
191           StubSym = MachineModuleInfoImpl::
192             StubValueTy(getSymbol(GV), !GV->hasInternalLinkage());
193       } else {
194         SymToPrint = getSymbol(GV);
195       }
196     } else {
197       SymToPrint = getSymbol(GV);
198     }
199 
200     O << *SymToPrint;
201 
202     printOffset(MO.getOffset(), O);
203     return;
204   }
205 
206   default:
207     O << "<unknown operand type: " << MO.getType() << ">";
208     return;
209   }
210 }
211 
212 /// PrintAsmOperand - Print out an operand for an inline asm expression.
213 ///
214 bool PPCAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
215                                     unsigned AsmVariant,
216                                     const char *ExtraCode, raw_ostream &O) {
217   // Does this asm operand have a single letter operand modifier?
218   if (ExtraCode && ExtraCode[0]) {
219     if (ExtraCode[1] != 0) return true; // Unknown modifier.
220 
221     switch (ExtraCode[0]) {
222     default:
223       // See if this is a generic print operand
224       return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O);
225     case 'c': // Don't print "$" before a global var name or constant.
226       break; // PPC never has a prefix.
227     case 'L': // Write second word of DImode reference.
228       // Verify that this operand has two consecutive registers.
229       if (!MI->getOperand(OpNo).isReg() ||
230           OpNo+1 == MI->getNumOperands() ||
231           !MI->getOperand(OpNo+1).isReg())
232         return true;
233       ++OpNo;   // Return the high-part.
234       break;
235     case 'I':
236       // Write 'i' if an integer constant, otherwise nothing.  Used to print
237       // addi vs add, etc.
238       if (MI->getOperand(OpNo).isImm())
239         O << "i";
240       return false;
241     }
242   }
243 
244   printOperand(MI, OpNo, O);
245   return false;
246 }
247 
248 // At the moment, all inline asm memory operands are a single register.
249 // In any case, the output of this routine should always be just one
250 // assembler operand.
251 
252 bool PPCAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
253                                           unsigned AsmVariant,
254                                           const char *ExtraCode,
255                                           raw_ostream &O) {
256   if (ExtraCode && ExtraCode[0]) {
257     if (ExtraCode[1] != 0) return true; // Unknown modifier.
258 
259     switch (ExtraCode[0]) {
260     default: return true;  // Unknown modifier.
261     case 'y': // A memory reference for an X-form instruction
262       {
263         const char *RegName = "r0";
264         if (!Subtarget.isDarwin()) RegName = stripRegisterPrefix(RegName);
265         O << RegName << ", ";
266         printOperand(MI, OpNo, O);
267         return false;
268       }
269     }
270   }
271 
272   assert(MI->getOperand(OpNo).isReg());
273   O << "0(";
274   printOperand(MI, OpNo, O);
275   O << ")";
276   return false;
277 }
278 
279 
280 /// lookUpOrCreateTOCEntry -- Given a symbol, look up whether a TOC entry
281 /// exists for it.  If not, create one.  Then return a symbol that references
282 /// the TOC entry.
283 MCSymbol *PPCAsmPrinter::lookUpOrCreateTOCEntry(MCSymbol *Sym) {
284 
285   MCSymbol *&TOCEntry = TOC[Sym];
286 
287   // To avoid name clash check if the name already exists.
288   while (TOCEntry == 0) {
289     if (OutContext.LookupSymbol(Twine(MAI->getPrivateGlobalPrefix()) +
290                                 "C" + Twine(TOCLabelID++)) == 0) {
291       TOCEntry = GetTempSymbol("C", TOCLabelID);
292     }
293   }
294 
295   return TOCEntry;
296 }
297 
298 
299 /// EmitInstruction -- Print out a single PowerPC MI in Darwin syntax to
300 /// the current output stream.
301 ///
302 void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) {
303   MCInst TmpInst;
304 
305   // Lower multi-instruction pseudo operations.
306   switch (MI->getOpcode()) {
307   default: break;
308   case TargetOpcode::DBG_VALUE:
309     llvm_unreachable("Should be handled target independently");
310   case PPC::MovePCtoLR:
311   case PPC::MovePCtoLR8: {
312     // Transform %LR = MovePCtoLR
313     // Into this, where the label is the PIC base:
314     //     bl L1$pb
315     // L1$pb:
316     MCSymbol *PICBase = MF->getPICBaseSymbol();
317 
318     // Emit the 'bl'.
319     OutStreamer.EmitInstruction(MCInstBuilder(PPC::BL)
320       // FIXME: We would like an efficient form for this, so we don't have to do
321       // a lot of extra uniquing.
322       .addExpr(MCSymbolRefExpr::Create(PICBase, OutContext)));
323 
324     // Emit the label.
325     OutStreamer.EmitLabel(PICBase);
326     return;
327   }
328   case PPC::LDtocJTI:
329   case PPC::LDtocCPT:
330   case PPC::LDtoc: {
331     // Transform %X3 = LDtoc <ga:@min1>, %X2
332     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
333 
334     // Change the opcode to LD, and the global address operand to be a
335     // reference to the TOC entry we will synthesize later.
336     TmpInst.setOpcode(PPC::LD);
337     const MachineOperand &MO = MI->getOperand(1);
338 
339     // Map symbol -> label of TOC entry
340     assert(MO.isGlobal() || MO.isCPI() || MO.isJTI());
341     MCSymbol *MOSymbol = 0;
342     if (MO.isGlobal())
343       MOSymbol = getSymbol(MO.getGlobal());
344     else if (MO.isCPI())
345       MOSymbol = GetCPISymbol(MO.getIndex());
346     else if (MO.isJTI())
347       MOSymbol = GetJTISymbol(MO.getIndex());
348 
349     MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol);
350 
351     const MCExpr *Exp =
352       MCSymbolRefExpr::Create(TOCEntry, MCSymbolRefExpr::VK_PPC_TOC,
353                               OutContext);
354     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
355     OutStreamer.EmitInstruction(TmpInst);
356     return;
357   }
358 
359   case PPC::ADDIStocHA: {
360     // Transform %Xd = ADDIStocHA %X2, <ga:@sym>
361     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
362 
363     // Change the opcode to ADDIS8.  If the global address is external,
364     // has common linkage, is a function address, or is a jump table
365     // address, then generate a TOC entry and reference that.  Otherwise
366     // reference the symbol directly.
367     TmpInst.setOpcode(PPC::ADDIS8);
368     const MachineOperand &MO = MI->getOperand(2);
369     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI()) &&
370            "Invalid operand for ADDIStocHA!");
371     MCSymbol *MOSymbol = 0;
372     bool IsExternal = false;
373     bool IsFunction = false;
374     bool IsCommon = false;
375     bool IsAvailExt = false;
376 
377     if (MO.isGlobal()) {
378       const GlobalValue *GValue = MO.getGlobal();
379       const GlobalAlias *GAlias = dyn_cast<GlobalAlias>(GValue);
380       const GlobalValue *RealGValue = GAlias ?
381         GAlias->resolveAliasedGlobal(false) : GValue;
382       MOSymbol = getSymbol(RealGValue);
383       const GlobalVariable *GVar = dyn_cast<GlobalVariable>(RealGValue);
384       IsExternal = GVar && !GVar->hasInitializer();
385       IsCommon = GVar && RealGValue->hasCommonLinkage();
386       IsFunction = !GVar;
387       IsAvailExt = GVar && RealGValue->hasAvailableExternallyLinkage();
388     } else if (MO.isCPI())
389       MOSymbol = GetCPISymbol(MO.getIndex());
390     else if (MO.isJTI())
391       MOSymbol = GetJTISymbol(MO.getIndex());
392 
393     if (IsExternal || IsFunction || IsCommon || IsAvailExt || MO.isJTI() ||
394         TM.getCodeModel() == CodeModel::Large)
395       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
396 
397     const MCExpr *Exp =
398       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_HA,
399                               OutContext);
400     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
401     OutStreamer.EmitInstruction(TmpInst);
402     return;
403   }
404   case PPC::LDtocL: {
405     // Transform %Xd = LDtocL <ga:@sym>, %Xs
406     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
407 
408     // Change the opcode to LD.  If the global address is external, has
409     // common linkage, or is a jump table address, then reference the
410     // associated TOC entry.  Otherwise reference the symbol directly.
411     TmpInst.setOpcode(PPC::LD);
412     const MachineOperand &MO = MI->getOperand(1);
413     assert((MO.isGlobal() || MO.isJTI() || MO.isCPI()) &&
414            "Invalid operand for LDtocL!");
415     MCSymbol *MOSymbol = 0;
416 
417     if (MO.isJTI())
418       MOSymbol = lookUpOrCreateTOCEntry(GetJTISymbol(MO.getIndex()));
419     else if (MO.isCPI()) {
420       MOSymbol = GetCPISymbol(MO.getIndex());
421       if (TM.getCodeModel() == CodeModel::Large)
422         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
423     }
424     else if (MO.isGlobal()) {
425       const GlobalValue *GValue = MO.getGlobal();
426       const GlobalAlias *GAlias = dyn_cast<GlobalAlias>(GValue);
427       const GlobalValue *RealGValue = GAlias ?
428         GAlias->resolveAliasedGlobal(false) : GValue;
429       MOSymbol = getSymbol(RealGValue);
430       const GlobalVariable *GVar = dyn_cast<GlobalVariable>(RealGValue);
431 
432       if (!GVar || !GVar->hasInitializer() || RealGValue->hasCommonLinkage() ||
433           RealGValue->hasAvailableExternallyLinkage() ||
434           TM.getCodeModel() == CodeModel::Large)
435         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
436     }
437 
438     const MCExpr *Exp =
439       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
440                               OutContext);
441     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
442     OutStreamer.EmitInstruction(TmpInst);
443     return;
444   }
445   case PPC::ADDItocL: {
446     // Transform %Xd = ADDItocL %Xs, <ga:@sym>
447     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
448 
449     // Change the opcode to ADDI8.  If the global address is external, then
450     // generate a TOC entry and reference that.  Otherwise reference the
451     // symbol directly.
452     TmpInst.setOpcode(PPC::ADDI8);
453     const MachineOperand &MO = MI->getOperand(2);
454     assert((MO.isGlobal() || MO.isCPI()) && "Invalid operand for ADDItocL");
455     MCSymbol *MOSymbol = 0;
456     bool IsExternal = false;
457     bool IsFunction = false;
458 
459     if (MO.isGlobal()) {
460       const GlobalValue *GValue = MO.getGlobal();
461       const GlobalAlias *GAlias = dyn_cast<GlobalAlias>(GValue);
462       const GlobalValue *RealGValue = GAlias ?
463         GAlias->resolveAliasedGlobal(false) : GValue;
464       MOSymbol = getSymbol(RealGValue);
465       const GlobalVariable *GVar = dyn_cast<GlobalVariable>(RealGValue);
466       IsExternal = GVar && !GVar->hasInitializer();
467       IsFunction = !GVar;
468     } else if (MO.isCPI())
469       MOSymbol = GetCPISymbol(MO.getIndex());
470 
471     if (IsFunction || IsExternal || TM.getCodeModel() == CodeModel::Large)
472       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
473 
474     const MCExpr *Exp =
475       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
476                               OutContext);
477     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
478     OutStreamer.EmitInstruction(TmpInst);
479     return;
480   }
481   case PPC::ADDISgotTprelHA: {
482     // Transform: %Xd = ADDISgotTprelHA %X2, <ga:@sym>
483     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
484     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
485     const MachineOperand &MO = MI->getOperand(2);
486     const GlobalValue *GValue = MO.getGlobal();
487     MCSymbol *MOSymbol = getSymbol(GValue);
488     const MCExpr *SymGotTprel =
489       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA,
490                               OutContext);
491     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS8)
492                                 .addReg(MI->getOperand(0).getReg())
493                                 .addReg(PPC::X2)
494                                 .addExpr(SymGotTprel));
495     return;
496   }
497   case PPC::LDgotTprelL: {
498     // Transform %Xd = LDgotTprelL <ga:@sym>, %Xs
499     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
500 
501     // Change the opcode to LD.
502     TmpInst.setOpcode(PPC::LD);
503     const MachineOperand &MO = MI->getOperand(1);
504     const GlobalValue *GValue = MO.getGlobal();
505     MCSymbol *MOSymbol = getSymbol(GValue);
506     const MCExpr *Exp =
507       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO,
508                               OutContext);
509     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
510     OutStreamer.EmitInstruction(TmpInst);
511     return;
512   }
513   case PPC::ADDIStlsgdHA: {
514     // Transform: %Xd = ADDIStlsgdHA %X2, <ga:@sym>
515     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
516     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
517     const MachineOperand &MO = MI->getOperand(2);
518     const GlobalValue *GValue = MO.getGlobal();
519     MCSymbol *MOSymbol = getSymbol(GValue);
520     const MCExpr *SymGotTlsGD =
521       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA,
522                               OutContext);
523     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS8)
524                                 .addReg(MI->getOperand(0).getReg())
525                                 .addReg(PPC::X2)
526                                 .addExpr(SymGotTlsGD));
527     return;
528   }
529   case PPC::ADDItlsgdL: {
530     // Transform: %Xd = ADDItlsgdL %Xs, <ga:@sym>
531     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsgd@l
532     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
533     const MachineOperand &MO = MI->getOperand(2);
534     const GlobalValue *GValue = MO.getGlobal();
535     MCSymbol *MOSymbol = getSymbol(GValue);
536     const MCExpr *SymGotTlsGD =
537       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO,
538                               OutContext);
539     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDI8)
540                                 .addReg(MI->getOperand(0).getReg())
541                                 .addReg(MI->getOperand(1).getReg())
542                                 .addExpr(SymGotTlsGD));
543     return;
544   }
545   case PPC::GETtlsADDR: {
546     // Transform: %X3 = GETtlsADDR %X3, <ga:@sym>
547     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsgd)
548     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
549 
550     StringRef Name = "__tls_get_addr";
551     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
552     const MCSymbolRefExpr *TlsRef =
553       MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);
554     const MachineOperand &MO = MI->getOperand(2);
555     const GlobalValue *GValue = MO.getGlobal();
556     MCSymbol *MOSymbol = getSymbol(GValue);
557     const MCExpr *SymVar =
558       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSGD,
559                               OutContext);
560     OutStreamer.EmitInstruction(MCInstBuilder(PPC::BL8_NOP_TLS)
561                                 .addExpr(TlsRef)
562                                 .addExpr(SymVar));
563     return;
564   }
565   case PPC::ADDIStlsldHA: {
566     // Transform: %Xd = ADDIStlsldHA %X2, <ga:@sym>
567     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsld@ha
568     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
569     const MachineOperand &MO = MI->getOperand(2);
570     const GlobalValue *GValue = MO.getGlobal();
571     MCSymbol *MOSymbol = getSymbol(GValue);
572     const MCExpr *SymGotTlsLD =
573       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA,
574                               OutContext);
575     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS8)
576                                 .addReg(MI->getOperand(0).getReg())
577                                 .addReg(PPC::X2)
578                                 .addExpr(SymGotTlsLD));
579     return;
580   }
581   case PPC::ADDItlsldL: {
582     // Transform: %Xd = ADDItlsldL %Xs, <ga:@sym>
583     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsld@l
584     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
585     const MachineOperand &MO = MI->getOperand(2);
586     const GlobalValue *GValue = MO.getGlobal();
587     MCSymbol *MOSymbol = getSymbol(GValue);
588     const MCExpr *SymGotTlsLD =
589       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO,
590                               OutContext);
591     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDI8)
592                                 .addReg(MI->getOperand(0).getReg())
593                                 .addReg(MI->getOperand(1).getReg())
594                                 .addExpr(SymGotTlsLD));
595     return;
596   }
597   case PPC::GETtlsldADDR: {
598     // Transform: %X3 = GETtlsldADDR %X3, <ga:@sym>
599     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsld)
600     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
601 
602     StringRef Name = "__tls_get_addr";
603     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
604     const MCSymbolRefExpr *TlsRef =
605       MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);
606     const MachineOperand &MO = MI->getOperand(2);
607     const GlobalValue *GValue = MO.getGlobal();
608     MCSymbol *MOSymbol = getSymbol(GValue);
609     const MCExpr *SymVar =
610       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSLD,
611                               OutContext);
612     OutStreamer.EmitInstruction(MCInstBuilder(PPC::BL8_NOP_TLS)
613                                 .addExpr(TlsRef)
614                                 .addExpr(SymVar));
615     return;
616   }
617   case PPC::ADDISdtprelHA: {
618     // Transform: %Xd = ADDISdtprelHA %X3, <ga:@sym>
619     // Into:      %Xd = ADDIS8 %X3, sym@dtprel@ha
620     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
621     const MachineOperand &MO = MI->getOperand(2);
622     const GlobalValue *GValue = MO.getGlobal();
623     MCSymbol *MOSymbol = getSymbol(GValue);
624     const MCExpr *SymDtprel =
625       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_HA,
626                               OutContext);
627     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS8)
628                                 .addReg(MI->getOperand(0).getReg())
629                                 .addReg(PPC::X3)
630                                 .addExpr(SymDtprel));
631     return;
632   }
633   case PPC::ADDIdtprelL: {
634     // Transform: %Xd = ADDIdtprelL %Xs, <ga:@sym>
635     // Into:      %Xd = ADDI8 %Xs, sym@dtprel@l
636     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
637     const MachineOperand &MO = MI->getOperand(2);
638     const GlobalValue *GValue = MO.getGlobal();
639     MCSymbol *MOSymbol = getSymbol(GValue);
640     const MCExpr *SymDtprel =
641       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_LO,
642                               OutContext);
643     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDI8)
644                                 .addReg(MI->getOperand(0).getReg())
645                                 .addReg(MI->getOperand(1).getReg())
646                                 .addExpr(SymDtprel));
647     return;
648   }
649   case PPC::MFOCRF:
650   case PPC::MFOCRF8:
651     if (!Subtarget.hasMFOCRF()) {
652       // Transform: %R3 = MFOCRF %CR7
653       // Into:      %R3 = MFCR   ;; cr7
654       unsigned NewOpcode =
655         MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
656       OutStreamer.AddComment(PPCInstPrinter::
657                              getRegisterName(MI->getOperand(1).getReg()));
658       OutStreamer.EmitInstruction(MCInstBuilder(NewOpcode)
659                                   .addReg(MI->getOperand(0).getReg()));
660       return;
661     }
662     break;
663   case PPC::MTOCRF:
664   case PPC::MTOCRF8:
665     if (!Subtarget.hasMFOCRF()) {
666       // Transform: %CR7 = MTOCRF %R3
667       // Into:      MTCRF mask, %R3 ;; cr7
668       unsigned NewOpcode =
669         MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
670       unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
671                               ->getEncodingValue(MI->getOperand(0).getReg());
672       OutStreamer.AddComment(PPCInstPrinter::
673                              getRegisterName(MI->getOperand(0).getReg()));
674       OutStreamer.EmitInstruction(MCInstBuilder(NewOpcode)
675                                   .addImm(Mask)
676                                   .addReg(MI->getOperand(1).getReg()));
677       return;
678     }
679     break;
680   case PPC::SYNC:
681     // In Book E sync is called msync, handle this special case here...
682     if (Subtarget.isBookE()) {
683       OutStreamer.EmitRawText(StringRef("\tmsync"));
684       return;
685     }
686     break;
687   case PPC::LD:
688   case PPC::STD:
689   case PPC::LWA_32:
690   case PPC::LWA: {
691     // Verify alignment is legal, so we don't create relocations
692     // that can't be supported.
693     // FIXME:  This test is currently disabled for Darwin.  The test
694     // suite shows a handful of test cases that fail this check for
695     // Darwin.  Those need to be investigated before this sanity test
696     // can be enabled for those subtargets.
697     if (!Subtarget.isDarwin()) {
698       unsigned OpNum = (MI->getOpcode() == PPC::STD) ? 2 : 1;
699       const MachineOperand &MO = MI->getOperand(OpNum);
700       if (MO.isGlobal() && MO.getGlobal()->getAlignment() < 4)
701         llvm_unreachable("Global must be word-aligned for LD, STD, LWA!");
702     }
703     // Now process the instruction normally.
704     break;
705   }
706   }
707 
708   LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
709   OutStreamer.EmitInstruction(TmpInst);
710 }
711 
712 void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
713   if (!Subtarget.isPPC64())  // linux/ppc32 - Normal entry label.
714     return AsmPrinter::EmitFunctionEntryLabel();
715 
716   // Emit an official procedure descriptor.
717   MCSectionSubPair Current = OutStreamer.getCurrentSection();
718   const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".opd",
719       ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
720       SectionKind::getReadOnly());
721   OutStreamer.SwitchSection(Section);
722   OutStreamer.EmitLabel(CurrentFnSym);
723   OutStreamer.EmitValueToAlignment(8);
724   MCSymbol *Symbol1 =
725     OutContext.GetOrCreateSymbol(".L." + Twine(CurrentFnSym->getName()));
726   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
727   // entry point.
728   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol1, OutContext),
729 			8 /*size*/);
730   MCSymbol *Symbol2 = OutContext.GetOrCreateSymbol(StringRef(".TOC."));
731   // Generates a R_PPC64_TOC relocation for TOC base insertion.
732   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol2,
733                         MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
734                         8/*size*/);
735   // Emit a null environment pointer.
736   OutStreamer.EmitIntValue(0, 8 /* size */);
737   OutStreamer.SwitchSection(Current.first, Current.second);
738 
739   MCSymbol *RealFnSym = OutContext.GetOrCreateSymbol(
740                           ".L." + Twine(CurrentFnSym->getName()));
741   OutStreamer.EmitLabel(RealFnSym);
742   CurrentFnSymForSize = RealFnSym;
743 }
744 
745 
746 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
747   const DataLayout *TD = TM.getDataLayout();
748 
749   bool isPPC64 = TD->getPointerSizeInBits() == 64;
750 
751   PPCTargetStreamer &TS =
752       static_cast<PPCTargetStreamer &>(OutStreamer.getTargetStreamer());
753 
754   if (isPPC64 && !TOC.empty()) {
755     const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".toc",
756         ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
757         SectionKind::getReadOnly());
758     OutStreamer.SwitchSection(Section);
759 
760     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
761          E = TOC.end(); I != E; ++I) {
762       OutStreamer.EmitLabel(I->second);
763       MCSymbol *S = OutContext.GetOrCreateSymbol(I->first->getName());
764       TS.emitTCEntry(*S);
765     }
766   }
767 
768   MachineModuleInfoELF &MMIELF =
769     MMI->getObjFileInfo<MachineModuleInfoELF>();
770 
771   MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
772   if (!Stubs.empty()) {
773     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
774     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
775       // L_foo$stub:
776       OutStreamer.EmitLabel(Stubs[i].first);
777       //   .long _foo
778       OutStreamer.EmitValue(MCSymbolRefExpr::Create(Stubs[i].second.getPointer(),
779                                                     OutContext),
780                             isPPC64 ? 8 : 4/*size*/);
781     }
782 
783     Stubs.clear();
784     OutStreamer.AddBlankLine();
785   }
786 
787   return AsmPrinter::doFinalization(M);
788 }
789 
790 /// EmitFunctionBodyEnd - Print the traceback table before the .size
791 /// directive.
792 ///
793 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
794   // Only the 64-bit target requires a traceback table.  For now,
795   // we only emit the word of zeroes that GDB requires to find
796   // the end of the function, and zeroes for the eight-byte
797   // mandatory fields.
798   // FIXME: We should fill in the eight-byte mandatory fields as described in
799   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
800   // currently make use of these fields).
801   if (Subtarget.isPPC64()) {
802     OutStreamer.EmitIntValue(0, 4/*size*/);
803     OutStreamer.EmitIntValue(0, 8/*size*/);
804   }
805 }
806 
807 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
808   static const char *const CPUDirectives[] = {
809     "",
810     "ppc",
811     "ppc440",
812     "ppc601",
813     "ppc602",
814     "ppc603",
815     "ppc7400",
816     "ppc750",
817     "ppc970",
818     "ppcA2",
819     "ppce500mc",
820     "ppce5500",
821     "power3",
822     "power4",
823     "power5",
824     "power5x",
825     "power6",
826     "power6x",
827     "power7",
828     "ppc64",
829     "ppc64le"
830   };
831 
832   unsigned Directive = Subtarget.getDarwinDirective();
833   if (Subtarget.hasMFOCRF() && Directive < PPC::DIR_970)
834     Directive = PPC::DIR_970;
835   if (Subtarget.hasAltivec() && Directive < PPC::DIR_7400)
836     Directive = PPC::DIR_7400;
837   if (Subtarget.isPPC64() && Directive < PPC::DIR_64)
838     Directive = PPC::DIR_64;
839   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
840 
841   // FIXME: This is a total hack, finish mc'izing the PPC backend.
842   if (OutStreamer.hasRawTextSupport()) {
843     assert(Directive < array_lengthof(CPUDirectives) &&
844            "CPUDirectives[] might not be up-to-date!");
845     OutStreamer.EmitRawText("\t.machine " + Twine(CPUDirectives[Directive]));
846   }
847 
848   // Prime text sections so they are adjacent.  This reduces the likelihood a
849   // large data or debug section causes a branch to exceed 16M limit.
850   const TargetLoweringObjectFileMachO &TLOFMacho =
851     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
852   OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection());
853   if (TM.getRelocationModel() == Reloc::PIC_) {
854     OutStreamer.SwitchSection(
855            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
856                                       MCSectionMachO::S_SYMBOL_STUBS |
857                                       MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
858                                       32, SectionKind::getText()));
859   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
860     OutStreamer.SwitchSection(
861            OutContext.getMachOSection("__TEXT","__symbol_stub1",
862                                       MCSectionMachO::S_SYMBOL_STUBS |
863                                       MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
864                                       16, SectionKind::getText()));
865   }
866   OutStreamer.SwitchSection(getObjFileLowering().getTextSection());
867 }
868 
869 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
870   // Remove $stub suffix, add $lazy_ptr.
871   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
872   return Ctx.GetOrCreateSymbol(NoStub + "$lazy_ptr");
873 }
874 
875 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
876   // Add $tmp suffix to $stub, yielding $stub$tmp.
877   return Ctx.GetOrCreateSymbol(Sym->getName() + "$tmp");
878 }
879 
880 void PPCDarwinAsmPrinter::
881 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
882   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
883   bool isDarwin = Subtarget.isDarwin();
884 
885   const TargetLoweringObjectFileMachO &TLOFMacho =
886     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
887 
888   // .lazy_symbol_pointer
889   const MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
890 
891   // Output stubs for dynamically-linked functions
892   if (TM.getRelocationModel() == Reloc::PIC_) {
893     const MCSection *StubSection =
894     OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
895                                MCSectionMachO::S_SYMBOL_STUBS |
896                                MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
897                                32, SectionKind::getText());
898     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
899       OutStreamer.SwitchSection(StubSection);
900       EmitAlignment(4);
901 
902       MCSymbol *Stub = Stubs[i].first;
903       MCSymbol *RawSym = Stubs[i].second.getPointer();
904       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
905       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
906 
907       OutStreamer.EmitLabel(Stub);
908       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
909 
910       const MCExpr *Anon = MCSymbolRefExpr::Create(AnonSymbol, OutContext);
911       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
912       const MCExpr *Sub =
913         MCBinaryExpr::CreateSub(LazyPtrExpr, Anon, OutContext);
914 
915       // mflr r0
916       OutStreamer.EmitInstruction(MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
917       // bcl 20, 31, AnonSymbol
918       OutStreamer.EmitInstruction(MCInstBuilder(PPC::BCLalways).addExpr(Anon));
919       OutStreamer.EmitLabel(AnonSymbol);
920       // mflr r11
921       OutStreamer.EmitInstruction(MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
922       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
923       const MCExpr *SubHa16 = PPCMCExpr::CreateHa(Sub, isDarwin, OutContext);
924       OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS)
925         .addReg(PPC::R11)
926         .addReg(PPC::R11)
927         .addExpr(SubHa16));
928       // mtlr r0
929       OutStreamer.EmitInstruction(MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
930 
931       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
932       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
933       const MCExpr *SubLo16 = PPCMCExpr::CreateLo(Sub, isDarwin, OutContext);
934       OutStreamer.EmitInstruction(MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
935         .addReg(PPC::R12)
936         .addExpr(SubLo16).addExpr(SubLo16)
937         .addReg(PPC::R11));
938       // mtctr r12
939       OutStreamer.EmitInstruction(MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
940       // bctr
941       OutStreamer.EmitInstruction(MCInstBuilder(PPC::BCTR));
942 
943       OutStreamer.SwitchSection(LSPSection);
944       OutStreamer.EmitLabel(LazyPtr);
945       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
946 
947       MCSymbol *DyldStubBindingHelper =
948         OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
949       if (isPPC64) {
950         // .quad dyld_stub_binding_helper
951         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
952       } else {
953         // .long dyld_stub_binding_helper
954         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
955       }
956     }
957     OutStreamer.AddBlankLine();
958     return;
959   }
960 
961   const MCSection *StubSection =
962     OutContext.getMachOSection("__TEXT","__symbol_stub1",
963                                MCSectionMachO::S_SYMBOL_STUBS |
964                                MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
965                                16, SectionKind::getText());
966   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
967     MCSymbol *Stub = Stubs[i].first;
968     MCSymbol *RawSym = Stubs[i].second.getPointer();
969     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
970     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
971 
972     OutStreamer.SwitchSection(StubSection);
973     EmitAlignment(4);
974     OutStreamer.EmitLabel(Stub);
975     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
976 
977     // lis r11, ha16(LazyPtr)
978     const MCExpr *LazyPtrHa16 =
979       PPCMCExpr::CreateHa(LazyPtrExpr, isDarwin, OutContext);
980     OutStreamer.EmitInstruction(MCInstBuilder(PPC::LIS)
981       .addReg(PPC::R11)
982       .addExpr(LazyPtrHa16));
983 
984     // ldu r12, lo16(LazyPtr)(r11)
985     // lwzu r12, lo16(LazyPtr)(r11)
986     const MCExpr *LazyPtrLo16 =
987       PPCMCExpr::CreateLo(LazyPtrExpr, isDarwin, OutContext);
988     OutStreamer.EmitInstruction(MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
989       .addReg(PPC::R12)
990       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
991       .addReg(PPC::R11));
992 
993     // mtctr r12
994     OutStreamer.EmitInstruction(MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
995     // bctr
996     OutStreamer.EmitInstruction(MCInstBuilder(PPC::BCTR));
997 
998     OutStreamer.SwitchSection(LSPSection);
999     OutStreamer.EmitLabel(LazyPtr);
1000     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1001 
1002     MCSymbol *DyldStubBindingHelper =
1003       OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1004     if (isPPC64) {
1005       // .quad dyld_stub_binding_helper
1006       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
1007     } else {
1008       // .long dyld_stub_binding_helper
1009       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
1010     }
1011   }
1012 
1013   OutStreamer.AddBlankLine();
1014 }
1015 
1016 
1017 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1018   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
1019 
1020   // Darwin/PPC always uses mach-o.
1021   const TargetLoweringObjectFileMachO &TLOFMacho =
1022     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1023   MachineModuleInfoMachO &MMIMacho =
1024     MMI->getObjFileInfo<MachineModuleInfoMachO>();
1025 
1026   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1027   if (!Stubs.empty())
1028     EmitFunctionStubs(Stubs);
1029 
1030   if (MAI->doesSupportExceptionHandling() && MMI) {
1031     // Add the (possibly multiple) personalities to the set of global values.
1032     // Only referenced functions get into the Personalities list.
1033     const std::vector<const Function*> &Personalities = MMI->getPersonalities();
1034     for (std::vector<const Function*>::const_iterator I = Personalities.begin(),
1035          E = Personalities.end(); I != E; ++I) {
1036       if (*I) {
1037         MCSymbol *NLPSym = getSymbolWithGlobalValueBase(*I, "$non_lazy_ptr");
1038         MachineModuleInfoImpl::StubValueTy &StubSym =
1039           MMIMacho.getGVStubEntry(NLPSym);
1040         StubSym = MachineModuleInfoImpl::StubValueTy(getSymbol(*I), true);
1041       }
1042     }
1043   }
1044 
1045   // Output stubs for dynamically-linked functions.
1046   Stubs = MMIMacho.GetGVStubList();
1047 
1048   // Output macho stubs for external and common global variables.
1049   if (!Stubs.empty()) {
1050     // Switch with ".non_lazy_symbol_pointer" directive.
1051     OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1052     EmitAlignment(isPPC64 ? 3 : 2);
1053 
1054     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1055       // L_foo$stub:
1056       OutStreamer.EmitLabel(Stubs[i].first);
1057       //   .indirect_symbol _foo
1058       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1059       OutStreamer.EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1060 
1061       if (MCSym.getInt())
1062         // External to current translation unit.
1063         OutStreamer.EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1064       else
1065         // Internal to current translation unit.
1066         //
1067         // When we place the LSDA into the TEXT section, the type info pointers
1068         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1069         // However, sometimes the types are local to the file. So we need to
1070         // fill in the value for the NLP in those cases.
1071         OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(),
1072                                                       OutContext),
1073                               isPPC64 ? 8 : 4/*size*/);
1074     }
1075 
1076     Stubs.clear();
1077     OutStreamer.AddBlankLine();
1078   }
1079 
1080   Stubs = MMIMacho.GetHiddenGVStubList();
1081   if (!Stubs.empty()) {
1082     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
1083     EmitAlignment(isPPC64 ? 3 : 2);
1084 
1085     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1086       // L_foo$stub:
1087       OutStreamer.EmitLabel(Stubs[i].first);
1088       //   .long _foo
1089       OutStreamer.EmitValue(MCSymbolRefExpr::
1090                             Create(Stubs[i].second.getPointer(),
1091                                    OutContext),
1092                             isPPC64 ? 8 : 4/*size*/);
1093     }
1094 
1095     Stubs.clear();
1096     OutStreamer.AddBlankLine();
1097   }
1098 
1099   // Funny Darwin hack: This flag tells the linker that no global symbols
1100   // contain code that falls through to other global symbols (e.g. the obvious
1101   // implementation of multiple entry points).  If this doesn't occur, the
1102   // linker can safely perform dead code stripping.  Since LLVM never generates
1103   // code that does this, it is always safe to set.
1104   OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1105 
1106   return AsmPrinter::doFinalization(M);
1107 }
1108 
1109 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1110 /// for a MachineFunction to the given output stream, in a format that the
1111 /// Darwin assembler can deal with.
1112 ///
1113 static AsmPrinter *createPPCAsmPrinterPass(TargetMachine &tm,
1114                                            MCStreamer &Streamer) {
1115   const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();
1116 
1117   if (Subtarget->isDarwin())
1118     return new PPCDarwinAsmPrinter(tm, Streamer);
1119   return new PPCLinuxAsmPrinter(tm, Streamer);
1120 }
1121 
1122 // Force static initialization.
1123 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1124   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1125   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1126 }
1127