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 #include "PPC.h"
20 #include "InstPrinter/PPCInstPrinter.h"
21 #include "MCTargetDesc/PPCMCExpr.h"
22 #include "MCTargetDesc/PPCPredicates.h"
23 #include "PPCMachineFunctionInfo.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/CodeGen/AsmPrinter.h"
31 #include "llvm/CodeGen/MachineConstantPool.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/MachineRegisterInfo.h"
37 #include "llvm/CodeGen/StackMaps.h"
38 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
39 #include "llvm/IR/Constants.h"
40 #include "llvm/IR/DebugInfo.h"
41 #include "llvm/IR/DerivedTypes.h"
42 #include "llvm/IR/Mangler.h"
43 #include "llvm/IR/Module.h"
44 #include "llvm/MC/MCAsmInfo.h"
45 #include "llvm/MC/MCContext.h"
46 #include "llvm/MC/MCExpr.h"
47 #include "llvm/MC/MCInst.h"
48 #include "llvm/MC/MCInstBuilder.h"
49 #include "llvm/MC/MCSectionELF.h"
50 #include "llvm/MC/MCSectionMachO.h"
51 #include "llvm/MC/MCStreamer.h"
52 #include "llvm/MC/MCSymbolELF.h"
53 #include "llvm/Support/CommandLine.h"
54 #include "llvm/Support/Debug.h"
55 #include "llvm/Support/ELF.h"
56 #include "llvm/Support/ErrorHandling.h"
57 #include "llvm/Support/MathExtras.h"
58 #include "llvm/Support/TargetRegistry.h"
59 #include "llvm/Support/raw_ostream.h"
60 #include "llvm/Target/TargetInstrInfo.h"
61 #include "llvm/Target/TargetOptions.h"
62 #include "llvm/Target/TargetRegisterInfo.h"
63 using namespace llvm;
64 
65 #define DEBUG_TYPE "asmprinter"
66 
67 namespace {
68 class PPCAsmPrinter : public AsmPrinter {
69 protected:
70   MapVector<MCSymbol *, MCSymbol *> TOC;
71   const PPCSubtarget *Subtarget;
72   StackMaps SM;
73 
74 public:
PPCAsmPrinter(TargetMachine & TM,std::unique_ptr<MCStreamer> Streamer)75   explicit PPCAsmPrinter(TargetMachine &TM,
76                          std::unique_ptr<MCStreamer> Streamer)
77       : AsmPrinter(TM, std::move(Streamer)), SM(*this) {}
78 
getPassName() const79   const char *getPassName() const override {
80     return "PowerPC Assembly Printer";
81   }
82 
83     MCSymbol *lookUpOrCreateTOCEntry(MCSymbol *Sym);
84 
85     void EmitInstruction(const MachineInstr *MI) override;
86 
87     void printOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
88 
89     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
90                          unsigned AsmVariant, const char *ExtraCode,
91                          raw_ostream &O) override;
92     bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
93                                unsigned AsmVariant, const char *ExtraCode,
94                                raw_ostream &O) override;
95 
96     void EmitEndOfAsmFile(Module &M) override;
97 
98     void LowerSTACKMAP(StackMaps &SM, const MachineInstr &MI);
99     void LowerPATCHPOINT(StackMaps &SM, const MachineInstr &MI);
100     void EmitTlsCall(const MachineInstr *MI, MCSymbolRefExpr::VariantKind VK);
runOnMachineFunction(MachineFunction & MF)101     bool runOnMachineFunction(MachineFunction &MF) override {
102       Subtarget = &MF.getSubtarget<PPCSubtarget>();
103       return AsmPrinter::runOnMachineFunction(MF);
104     }
105   };
106 
107   /// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux
108   class PPCLinuxAsmPrinter : public PPCAsmPrinter {
109   public:
PPCLinuxAsmPrinter(TargetMachine & TM,std::unique_ptr<MCStreamer> Streamer)110     explicit PPCLinuxAsmPrinter(TargetMachine &TM,
111                                 std::unique_ptr<MCStreamer> Streamer)
112         : PPCAsmPrinter(TM, std::move(Streamer)) {}
113 
getPassName() const114     const char *getPassName() const override {
115       return "Linux PPC Assembly Printer";
116     }
117 
118     bool doFinalization(Module &M) override;
119     void EmitStartOfAsmFile(Module &M) override;
120 
121     void EmitFunctionEntryLabel() override;
122 
123     void EmitFunctionBodyStart() override;
124     void EmitFunctionBodyEnd() override;
125   };
126 
127   /// PPCDarwinAsmPrinter - PowerPC assembly printer, customized for Darwin/Mac
128   /// OS X
129   class PPCDarwinAsmPrinter : public PPCAsmPrinter {
130   public:
PPCDarwinAsmPrinter(TargetMachine & TM,std::unique_ptr<MCStreamer> Streamer)131     explicit PPCDarwinAsmPrinter(TargetMachine &TM,
132                                  std::unique_ptr<MCStreamer> Streamer)
133         : PPCAsmPrinter(TM, std::move(Streamer)) {}
134 
getPassName() const135     const char *getPassName() const override {
136       return "Darwin PPC Assembly Printer";
137     }
138 
139     bool doFinalization(Module &M) override;
140     void EmitStartOfAsmFile(Module &M) override;
141 
142     void EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs);
143   };
144 } // end of anonymous namespace
145 
146 /// stripRegisterPrefix - This method strips the character prefix from a
147 /// register name so that only the number is left.  Used by for linux asm.
stripRegisterPrefix(const char * RegName)148 static const char *stripRegisterPrefix(const char *RegName) {
149   switch (RegName[0]) {
150     case 'r':
151     case 'f':
152     case 'q': // for QPX
153     case 'v':
154       if (RegName[1] == 's')
155         return RegName + 2;
156       return RegName + 1;
157     case 'c': if (RegName[1] == 'r') return RegName + 2;
158   }
159 
160   return RegName;
161 }
162 
printOperand(const MachineInstr * MI,unsigned OpNo,raw_ostream & O)163 void PPCAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
164                                  raw_ostream &O) {
165   const DataLayout &DL = getDataLayout();
166   const MachineOperand &MO = MI->getOperand(OpNo);
167 
168   switch (MO.getType()) {
169   case MachineOperand::MO_Register: {
170     const char *RegName = PPCInstPrinter::getRegisterName(MO.getReg());
171     // Linux assembler (Others?) does not take register mnemonics.
172     // FIXME - What about special registers used in mfspr/mtspr?
173     if (!Subtarget->isDarwin())
174       RegName = stripRegisterPrefix(RegName);
175     O << RegName;
176     return;
177   }
178   case MachineOperand::MO_Immediate:
179     O << MO.getImm();
180     return;
181 
182   case MachineOperand::MO_MachineBasicBlock:
183     MO.getMBB()->getSymbol()->print(O, MAI);
184     return;
185   case MachineOperand::MO_ConstantPoolIndex:
186     O << DL.getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
187       << MO.getIndex();
188     return;
189   case MachineOperand::MO_BlockAddress:
190     GetBlockAddressSymbol(MO.getBlockAddress())->print(O, MAI);
191     return;
192   case MachineOperand::MO_GlobalAddress: {
193     // Computing the address of a global symbol, not calling it.
194     const GlobalValue *GV = MO.getGlobal();
195     MCSymbol *SymToPrint;
196 
197     // External or weakly linked global variables need non-lazily-resolved stubs
198     if (TM.getRelocationModel() != Reloc::Static &&
199         !GV->isStrongDefinitionForLinker()) {
200       if (!GV->hasHiddenVisibility()) {
201         SymToPrint = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
202         MachineModuleInfoImpl::StubValueTy &StubSym =
203             MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(
204                 SymToPrint);
205         if (!StubSym.getPointer())
206           StubSym = MachineModuleInfoImpl::
207             StubValueTy(getSymbol(GV), !GV->hasInternalLinkage());
208       } else if (GV->isDeclaration() || GV->hasCommonLinkage() ||
209                  GV->hasAvailableExternallyLinkage()) {
210         SymToPrint = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
211 
212         MachineModuleInfoImpl::StubValueTy &StubSym =
213             MMI->getObjFileInfo<MachineModuleInfoMachO>().getHiddenGVStubEntry(
214                 SymToPrint);
215         if (!StubSym.getPointer())
216           StubSym = MachineModuleInfoImpl::
217             StubValueTy(getSymbol(GV), !GV->hasInternalLinkage());
218       } else {
219         SymToPrint = getSymbol(GV);
220       }
221     } else {
222       SymToPrint = getSymbol(GV);
223     }
224 
225     SymToPrint->print(O, MAI);
226 
227     printOffset(MO.getOffset(), O);
228     return;
229   }
230 
231   default:
232     O << "<unknown operand type: " << (unsigned)MO.getType() << ">";
233     return;
234   }
235 }
236 
237 /// PrintAsmOperand - Print out an operand for an inline asm expression.
238 ///
PrintAsmOperand(const MachineInstr * MI,unsigned OpNo,unsigned AsmVariant,const char * ExtraCode,raw_ostream & O)239 bool PPCAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
240                                     unsigned AsmVariant,
241                                     const char *ExtraCode, raw_ostream &O) {
242   // Does this asm operand have a single letter operand modifier?
243   if (ExtraCode && ExtraCode[0]) {
244     if (ExtraCode[1] != 0) return true; // Unknown modifier.
245 
246     switch (ExtraCode[0]) {
247     default:
248       // See if this is a generic print operand
249       return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O);
250     case 'c': // Don't print "$" before a global var name or constant.
251       break; // PPC never has a prefix.
252     case 'L': // Write second word of DImode reference.
253       // Verify that this operand has two consecutive registers.
254       if (!MI->getOperand(OpNo).isReg() ||
255           OpNo+1 == MI->getNumOperands() ||
256           !MI->getOperand(OpNo+1).isReg())
257         return true;
258       ++OpNo;   // Return the high-part.
259       break;
260     case 'I':
261       // Write 'i' if an integer constant, otherwise nothing.  Used to print
262       // addi vs add, etc.
263       if (MI->getOperand(OpNo).isImm())
264         O << "i";
265       return false;
266     }
267   }
268 
269   printOperand(MI, OpNo, O);
270   return false;
271 }
272 
273 // At the moment, all inline asm memory operands are a single register.
274 // In any case, the output of this routine should always be just one
275 // assembler operand.
276 
PrintAsmMemoryOperand(const MachineInstr * MI,unsigned OpNo,unsigned AsmVariant,const char * ExtraCode,raw_ostream & O)277 bool PPCAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
278                                           unsigned AsmVariant,
279                                           const char *ExtraCode,
280                                           raw_ostream &O) {
281   if (ExtraCode && ExtraCode[0]) {
282     if (ExtraCode[1] != 0) return true; // Unknown modifier.
283 
284     switch (ExtraCode[0]) {
285     default: return true;  // Unknown modifier.
286     case 'y': // A memory reference for an X-form instruction
287       {
288         const char *RegName = "r0";
289         if (!Subtarget->isDarwin())
290           RegName = stripRegisterPrefix(RegName);
291         O << RegName << ", ";
292         printOperand(MI, OpNo, O);
293         return false;
294       }
295     case 'U': // Print 'u' for update form.
296     case 'X': // Print 'x' for indexed form.
297     {
298       // FIXME: Currently for PowerPC memory operands are always loaded
299       // into a register, so we never get an update or indexed form.
300       // This is bad even for offset forms, since even if we know we
301       // have a value in -16(r1), we will generate a load into r<n>
302       // and then load from 0(r<n>).  Until that issue is fixed,
303       // tolerate 'U' and 'X' but don't output anything.
304       assert(MI->getOperand(OpNo).isReg());
305       return false;
306     }
307     }
308   }
309 
310   assert(MI->getOperand(OpNo).isReg());
311   O << "0(";
312   printOperand(MI, OpNo, O);
313   O << ")";
314   return false;
315 }
316 
317 /// lookUpOrCreateTOCEntry -- Given a symbol, look up whether a TOC entry
318 /// exists for it.  If not, create one.  Then return a symbol that references
319 /// the TOC entry.
lookUpOrCreateTOCEntry(MCSymbol * Sym)320 MCSymbol *PPCAsmPrinter::lookUpOrCreateTOCEntry(MCSymbol *Sym) {
321   MCSymbol *&TOCEntry = TOC[Sym];
322   if (!TOCEntry)
323     TOCEntry = createTempSymbol("C");
324   return TOCEntry;
325 }
326 
EmitEndOfAsmFile(Module & M)327 void PPCAsmPrinter::EmitEndOfAsmFile(Module &M) {
328   SM.serializeToStackMapSection();
329 }
330 
LowerSTACKMAP(StackMaps & SM,const MachineInstr & MI)331 void PPCAsmPrinter::LowerSTACKMAP(StackMaps &SM, const MachineInstr &MI) {
332   unsigned NumNOPBytes = MI.getOperand(1).getImm();
333 
334   SM.recordStackMap(MI);
335   assert(NumNOPBytes % 4 == 0 && "Invalid number of NOP bytes requested!");
336 
337   // Scan ahead to trim the shadow.
338   const MachineBasicBlock &MBB = *MI.getParent();
339   MachineBasicBlock::const_iterator MII(MI);
340   ++MII;
341   while (NumNOPBytes > 0) {
342     if (MII == MBB.end() || MII->isCall() ||
343         MII->getOpcode() == PPC::DBG_VALUE ||
344         MII->getOpcode() == TargetOpcode::PATCHPOINT ||
345         MII->getOpcode() == TargetOpcode::STACKMAP)
346       break;
347     ++MII;
348     NumNOPBytes -= 4;
349   }
350 
351   // Emit nops.
352   for (unsigned i = 0; i < NumNOPBytes; i += 4)
353     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
354 }
355 
356 // Lower a patchpoint of the form:
357 // [<def>], <id>, <numBytes>, <target>, <numArgs>
LowerPATCHPOINT(StackMaps & SM,const MachineInstr & MI)358 void PPCAsmPrinter::LowerPATCHPOINT(StackMaps &SM, const MachineInstr &MI) {
359   SM.recordPatchPoint(MI);
360   PatchPointOpers Opers(&MI);
361 
362   unsigned EncodedBytes = 0;
363   const MachineOperand &CalleeMO =
364     Opers.getMetaOper(PatchPointOpers::TargetPos);
365 
366   if (CalleeMO.isImm()) {
367     int64_t CallTarget = Opers.getMetaOper(PatchPointOpers::TargetPos).getImm();
368     if (CallTarget) {
369       assert((CallTarget & 0xFFFFFFFFFFFF) == CallTarget &&
370              "High 16 bits of call target should be zero.");
371       unsigned ScratchReg = MI.getOperand(Opers.getNextScratchIdx()).getReg();
372       EncodedBytes = 0;
373       // Materialize the jump address:
374       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LI8)
375                                       .addReg(ScratchReg)
376                                       .addImm((CallTarget >> 32) & 0xFFFF));
377       ++EncodedBytes;
378       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::RLDIC)
379                                       .addReg(ScratchReg)
380                                       .addReg(ScratchReg)
381                                       .addImm(32).addImm(16));
382       ++EncodedBytes;
383       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ORIS8)
384                                       .addReg(ScratchReg)
385                                       .addReg(ScratchReg)
386                                       .addImm((CallTarget >> 16) & 0xFFFF));
387       ++EncodedBytes;
388       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ORI8)
389                                       .addReg(ScratchReg)
390                                       .addReg(ScratchReg)
391                                       .addImm(CallTarget & 0xFFFF));
392 
393       // Save the current TOC pointer before the remote call.
394       int TOCSaveOffset = Subtarget->isELFv2ABI() ? 24 : 40;
395       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::STD)
396                                       .addReg(PPC::X2)
397                                       .addImm(TOCSaveOffset)
398                                       .addReg(PPC::X1));
399       ++EncodedBytes;
400 
401       // If we're on ELFv1, then we need to load the actual function pointer
402       // from the function descriptor.
403       if (!Subtarget->isELFv2ABI()) {
404         // Load the new TOC pointer and the function address, but not r11
405         // (needing this is rare, and loading it here would prevent passing it
406         // via a 'nest' parameter.
407         EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
408                                         .addReg(PPC::X2)
409                                         .addImm(8)
410                                         .addReg(ScratchReg));
411         ++EncodedBytes;
412         EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
413                                         .addReg(ScratchReg)
414                                         .addImm(0)
415                                         .addReg(ScratchReg));
416         ++EncodedBytes;
417       }
418 
419       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR8)
420                                       .addReg(ScratchReg));
421       ++EncodedBytes;
422       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTRL8));
423       ++EncodedBytes;
424 
425       // Restore the TOC pointer after the call.
426       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
427                                       .addReg(PPC::X2)
428                                       .addImm(TOCSaveOffset)
429                                       .addReg(PPC::X1));
430       ++EncodedBytes;
431     }
432   } else if (CalleeMO.isGlobal()) {
433     const GlobalValue *GValue = CalleeMO.getGlobal();
434     MCSymbol *MOSymbol = getSymbol(GValue);
435     const MCExpr *SymVar = MCSymbolRefExpr::create(MOSymbol, OutContext);
436 
437     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL8_NOP)
438                                     .addExpr(SymVar));
439     EncodedBytes += 2;
440   }
441 
442   // Each instruction is 4 bytes.
443   EncodedBytes *= 4;
444 
445   // Emit padding.
446   unsigned NumBytes = Opers.getMetaOper(PatchPointOpers::NBytesPos).getImm();
447   assert(NumBytes >= EncodedBytes &&
448          "Patchpoint can't request size less than the length of a call.");
449   assert((NumBytes - EncodedBytes) % 4 == 0 &&
450          "Invalid number of NOP bytes requested!");
451   for (unsigned i = EncodedBytes; i < NumBytes; i += 4)
452     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
453 }
454 
455 /// EmitTlsCall -- Given a GETtls[ld]ADDR[32] instruction, print a
456 /// call to __tls_get_addr to the current output stream.
EmitTlsCall(const MachineInstr * MI,MCSymbolRefExpr::VariantKind VK)457 void PPCAsmPrinter::EmitTlsCall(const MachineInstr *MI,
458                                 MCSymbolRefExpr::VariantKind VK) {
459   StringRef Name = "__tls_get_addr";
460   MCSymbol *TlsGetAddr = OutContext.getOrCreateSymbol(Name);
461   MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
462 
463   assert(MI->getOperand(0).isReg() &&
464          ((Subtarget->isPPC64() && MI->getOperand(0).getReg() == PPC::X3) ||
465           (!Subtarget->isPPC64() && MI->getOperand(0).getReg() == PPC::R3)) &&
466          "GETtls[ld]ADDR[32] must define GPR3");
467   assert(MI->getOperand(1).isReg() &&
468          ((Subtarget->isPPC64() && MI->getOperand(1).getReg() == PPC::X3) ||
469           (!Subtarget->isPPC64() && MI->getOperand(1).getReg() == PPC::R3)) &&
470          "GETtls[ld]ADDR[32] must read GPR3");
471 
472   if (!Subtarget->isPPC64() && !Subtarget->isDarwin() &&
473       TM.getRelocationModel() == Reloc::PIC_)
474     Kind = MCSymbolRefExpr::VK_PLT;
475   const MCSymbolRefExpr *TlsRef =
476     MCSymbolRefExpr::create(TlsGetAddr, Kind, OutContext);
477   const MachineOperand &MO = MI->getOperand(2);
478   const GlobalValue *GValue = MO.getGlobal();
479   MCSymbol *MOSymbol = getSymbol(GValue);
480   const MCExpr *SymVar = MCSymbolRefExpr::create(MOSymbol, VK, OutContext);
481   EmitToStreamer(*OutStreamer,
482                  MCInstBuilder(Subtarget->isPPC64() ?
483                                PPC::BL8_NOP_TLS : PPC::BL_TLS)
484                  .addExpr(TlsRef)
485                  .addExpr(SymVar));
486 }
487 
488 /// EmitInstruction -- Print out a single PowerPC MI in Darwin syntax to
489 /// the current output stream.
490 ///
EmitInstruction(const MachineInstr * MI)491 void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) {
492   MCInst TmpInst;
493   bool isPPC64 = Subtarget->isPPC64();
494   bool isDarwin = TM.getTargetTriple().isOSDarwin();
495   const Module *M = MF->getFunction()->getParent();
496   PICLevel::Level PL = M->getPICLevel();
497 
498   // Lower multi-instruction pseudo operations.
499   switch (MI->getOpcode()) {
500   default: break;
501   case TargetOpcode::DBG_VALUE:
502     llvm_unreachable("Should be handled target independently");
503   case TargetOpcode::STACKMAP:
504     return LowerSTACKMAP(SM, *MI);
505   case TargetOpcode::PATCHPOINT:
506     return LowerPATCHPOINT(SM, *MI);
507 
508   case PPC::MoveGOTtoLR: {
509     // Transform %LR = MoveGOTtoLR
510     // Into this: bl _GLOBAL_OFFSET_TABLE_@local-4
511     // _GLOBAL_OFFSET_TABLE_@local-4 (instruction preceding
512     // _GLOBAL_OFFSET_TABLE_) has exactly one instruction:
513     //      blrl
514     // This will return the pointer to _GLOBAL_OFFSET_TABLE_@local
515     MCSymbol *GOTSymbol =
516       OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
517     const MCExpr *OffsExpr =
518       MCBinaryExpr::createSub(MCSymbolRefExpr::create(GOTSymbol,
519                                                       MCSymbolRefExpr::VK_PPC_LOCAL,
520                                                       OutContext),
521                               MCConstantExpr::create(4, OutContext),
522                               OutContext);
523 
524     // Emit the 'bl'.
525     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL).addExpr(OffsExpr));
526     return;
527   }
528   case PPC::MovePCtoLR:
529   case PPC::MovePCtoLR8: {
530     // Transform %LR = MovePCtoLR
531     // Into this, where the label is the PIC base:
532     //     bl L1$pb
533     // L1$pb:
534     MCSymbol *PICBase = MF->getPICBaseSymbol();
535 
536     // Emit the 'bl'.
537     EmitToStreamer(*OutStreamer,
538                    MCInstBuilder(PPC::BL)
539                        // FIXME: We would like an efficient form for this, so we
540                        // don't have to do a lot of extra uniquing.
541                        .addExpr(MCSymbolRefExpr::create(PICBase, OutContext)));
542 
543     // Emit the label.
544     OutStreamer->EmitLabel(PICBase);
545     return;
546   }
547   case PPC::UpdateGBR: {
548     // Transform %Rd = UpdateGBR(%Rt, %Ri)
549     // Into: lwz %Rt, .L0$poff - .L0$pb(%Ri)
550     //       add %Rd, %Rt, %Ri
551     // Get the offset from the GOT Base Register to the GOT
552     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
553     MCSymbol *PICOffset =
554       MF->getInfo<PPCFunctionInfo>()->getPICOffsetSymbol();
555     TmpInst.setOpcode(PPC::LWZ);
556     const MCExpr *Exp =
557       MCSymbolRefExpr::create(PICOffset, MCSymbolRefExpr::VK_None, OutContext);
558     const MCExpr *PB =
559       MCSymbolRefExpr::create(MF->getPICBaseSymbol(),
560                               MCSymbolRefExpr::VK_None,
561                               OutContext);
562     const MCOperand TR = TmpInst.getOperand(1);
563     const MCOperand PICR = TmpInst.getOperand(0);
564 
565     // Step 1: lwz %Rt, .L$poff - .L$pb(%Ri)
566     TmpInst.getOperand(1) =
567         MCOperand::createExpr(MCBinaryExpr::createSub(Exp, PB, OutContext));
568     TmpInst.getOperand(0) = TR;
569     TmpInst.getOperand(2) = PICR;
570     EmitToStreamer(*OutStreamer, TmpInst);
571 
572     TmpInst.setOpcode(PPC::ADD4);
573     TmpInst.getOperand(0) = PICR;
574     TmpInst.getOperand(1) = TR;
575     TmpInst.getOperand(2) = PICR;
576     EmitToStreamer(*OutStreamer, TmpInst);
577     return;
578   }
579   case PPC::LWZtoc: {
580     // Transform %R3 = LWZtoc <ga:@min1>, %R2
581     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
582 
583     // Change the opcode to LWZ, and the global address operand to be a
584     // reference to the GOT entry we will synthesize later.
585     TmpInst.setOpcode(PPC::LWZ);
586     const MachineOperand &MO = MI->getOperand(1);
587 
588     // Map symbol -> label of TOC entry
589     assert(MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress());
590     MCSymbol *MOSymbol = nullptr;
591     if (MO.isGlobal())
592       MOSymbol = getSymbol(MO.getGlobal());
593     else if (MO.isCPI())
594       MOSymbol = GetCPISymbol(MO.getIndex());
595     else if (MO.isJTI())
596       MOSymbol = GetJTISymbol(MO.getIndex());
597     else if (MO.isBlockAddress())
598       MOSymbol = GetBlockAddressSymbol(MO.getBlockAddress());
599 
600     if (PL == PICLevel::Small) {
601       const MCExpr *Exp =
602         MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_GOT,
603                                 OutContext);
604       TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
605     } else {
606       MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol);
607 
608       const MCExpr *Exp =
609         MCSymbolRefExpr::create(TOCEntry, MCSymbolRefExpr::VK_None,
610                                 OutContext);
611       const MCExpr *PB =
612         MCSymbolRefExpr::create(OutContext.getOrCreateSymbol(Twine(".LTOC")),
613                                                              OutContext);
614       Exp = MCBinaryExpr::createSub(Exp, PB, OutContext);
615       TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
616     }
617     EmitToStreamer(*OutStreamer, TmpInst);
618     return;
619   }
620   case PPC::LDtocJTI:
621   case PPC::LDtocCPT:
622   case PPC::LDtocBA:
623   case PPC::LDtoc: {
624     // Transform %X3 = LDtoc <ga:@min1>, %X2
625     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
626 
627     // Change the opcode to LD, and the global address operand to be a
628     // reference to the TOC entry we will synthesize later.
629     TmpInst.setOpcode(PPC::LD);
630     const MachineOperand &MO = MI->getOperand(1);
631 
632     // Map symbol -> label of TOC entry
633     assert(MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress());
634     MCSymbol *MOSymbol = nullptr;
635     if (MO.isGlobal())
636       MOSymbol = getSymbol(MO.getGlobal());
637     else if (MO.isCPI())
638       MOSymbol = GetCPISymbol(MO.getIndex());
639     else if (MO.isJTI())
640       MOSymbol = GetJTISymbol(MO.getIndex());
641     else if (MO.isBlockAddress())
642       MOSymbol = GetBlockAddressSymbol(MO.getBlockAddress());
643 
644     MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol);
645 
646     const MCExpr *Exp =
647       MCSymbolRefExpr::create(TOCEntry, MCSymbolRefExpr::VK_PPC_TOC,
648                               OutContext);
649     TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
650     EmitToStreamer(*OutStreamer, TmpInst);
651     return;
652   }
653 
654   case PPC::ADDIStocHA: {
655     // Transform %Xd = ADDIStocHA %X2, <ga:@sym>
656     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
657 
658     // Change the opcode to ADDIS8.  If the global address is external, has
659     // common linkage, is a non-local function address, or is a jump table
660     // address, then generate a TOC entry and reference that.  Otherwise
661     // reference the symbol directly.
662     TmpInst.setOpcode(PPC::ADDIS8);
663     const MachineOperand &MO = MI->getOperand(2);
664     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() ||
665             MO.isBlockAddress()) &&
666            "Invalid operand for ADDIStocHA!");
667     MCSymbol *MOSymbol = nullptr;
668     bool GlobalToc = false;
669 
670     if (MO.isGlobal()) {
671       const GlobalValue *GV = MO.getGlobal();
672       MOSymbol = getSymbol(GV);
673       unsigned char GVFlags = Subtarget->classifyGlobalReference(GV);
674       GlobalToc = (GVFlags & PPCII::MO_NLP_FLAG);
675     } else if (MO.isCPI()) {
676       MOSymbol = GetCPISymbol(MO.getIndex());
677     } else if (MO.isJTI()) {
678       MOSymbol = GetJTISymbol(MO.getIndex());
679     } else if (MO.isBlockAddress()) {
680       MOSymbol = GetBlockAddressSymbol(MO.getBlockAddress());
681     }
682 
683     if (GlobalToc || MO.isJTI() || MO.isBlockAddress() ||
684         TM.getCodeModel() == CodeModel::Large)
685       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
686 
687     const MCExpr *Exp =
688       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_HA,
689                               OutContext);
690     TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
691     EmitToStreamer(*OutStreamer, TmpInst);
692     return;
693   }
694   case PPC::LDtocL: {
695     // Transform %Xd = LDtocL <ga:@sym>, %Xs
696     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
697 
698     // Change the opcode to LD.  If the global address is external, has
699     // common linkage, or is a jump table address, then reference the
700     // associated TOC entry.  Otherwise reference the symbol directly.
701     TmpInst.setOpcode(PPC::LD);
702     const MachineOperand &MO = MI->getOperand(1);
703     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() ||
704             MO.isBlockAddress()) &&
705            "Invalid operand for LDtocL!");
706     MCSymbol *MOSymbol = nullptr;
707 
708     if (MO.isJTI())
709       MOSymbol = lookUpOrCreateTOCEntry(GetJTISymbol(MO.getIndex()));
710     else if (MO.isBlockAddress()) {
711       MOSymbol = GetBlockAddressSymbol(MO.getBlockAddress());
712       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
713     }
714     else if (MO.isCPI()) {
715       MOSymbol = GetCPISymbol(MO.getIndex());
716       if (TM.getCodeModel() == CodeModel::Large)
717         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
718     }
719     else if (MO.isGlobal()) {
720       const GlobalValue *GV = MO.getGlobal();
721       MOSymbol = getSymbol(GV);
722       DEBUG(
723         unsigned char GVFlags = Subtarget->classifyGlobalReference(GV);
724         assert((GVFlags & PPCII::MO_NLP_FLAG) &&
725                "LDtocL used on symbol that could be accessed directly is "
726                "invalid. Must match ADDIStocHA."));
727       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
728     }
729 
730     const MCExpr *Exp =
731       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
732                               OutContext);
733     TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
734     EmitToStreamer(*OutStreamer, TmpInst);
735     return;
736   }
737   case PPC::ADDItocL: {
738     // Transform %Xd = ADDItocL %Xs, <ga:@sym>
739     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
740 
741     // Change the opcode to ADDI8.  If the global address is external, then
742     // generate a TOC entry and reference that.  Otherwise reference the
743     // symbol directly.
744     TmpInst.setOpcode(PPC::ADDI8);
745     const MachineOperand &MO = MI->getOperand(2);
746     assert((MO.isGlobal() || MO.isCPI()) && "Invalid operand for ADDItocL");
747     MCSymbol *MOSymbol = nullptr;
748 
749     if (MO.isGlobal()) {
750       const GlobalValue *GV = MO.getGlobal();
751       DEBUG(
752         unsigned char GVFlags = Subtarget->classifyGlobalReference(GV);
753         assert (
754             !(GVFlags & PPCII::MO_NLP_FLAG) &&
755             "Interposable definitions must use indirect access."));
756       MOSymbol = getSymbol(GV);
757     } else if (MO.isCPI()) {
758       MOSymbol = GetCPISymbol(MO.getIndex());
759     }
760 
761     const MCExpr *Exp =
762       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
763                               OutContext);
764     TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
765     EmitToStreamer(*OutStreamer, TmpInst);
766     return;
767   }
768   case PPC::ADDISgotTprelHA: {
769     // Transform: %Xd = ADDISgotTprelHA %X2, <ga:@sym>
770     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
771     assert(Subtarget->isPPC64() && "Not supported for 32-bit PowerPC");
772     const MachineOperand &MO = MI->getOperand(2);
773     const GlobalValue *GValue = MO.getGlobal();
774     MCSymbol *MOSymbol = getSymbol(GValue);
775     const MCExpr *SymGotTprel =
776       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA,
777                               OutContext);
778     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
779                                  .addReg(MI->getOperand(0).getReg())
780                                  .addReg(MI->getOperand(1).getReg())
781                                  .addExpr(SymGotTprel));
782     return;
783   }
784   case PPC::LDgotTprelL:
785   case PPC::LDgotTprelL32: {
786     // Transform %Xd = LDgotTprelL <ga:@sym>, %Xs
787     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
788 
789     // Change the opcode to LD.
790     TmpInst.setOpcode(isPPC64 ? PPC::LD : PPC::LWZ);
791     const MachineOperand &MO = MI->getOperand(1);
792     const GlobalValue *GValue = MO.getGlobal();
793     MCSymbol *MOSymbol = getSymbol(GValue);
794     const MCExpr *Exp =
795       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO,
796                               OutContext);
797     TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
798     EmitToStreamer(*OutStreamer, TmpInst);
799     return;
800   }
801 
802   case PPC::PPC32PICGOT: {
803     MCSymbol *GOTSymbol = OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
804     MCSymbol *GOTRef = OutContext.createTempSymbol();
805     MCSymbol *NextInstr = OutContext.createTempSymbol();
806 
807     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL)
808       // FIXME: We would like an efficient form for this, so we don't have to do
809       // a lot of extra uniquing.
810       .addExpr(MCSymbolRefExpr::create(NextInstr, OutContext)));
811     const MCExpr *OffsExpr =
812       MCBinaryExpr::createSub(MCSymbolRefExpr::create(GOTSymbol, OutContext),
813                                 MCSymbolRefExpr::create(GOTRef, OutContext),
814         OutContext);
815     OutStreamer->EmitLabel(GOTRef);
816     OutStreamer->EmitValue(OffsExpr, 4);
817     OutStreamer->EmitLabel(NextInstr);
818     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR)
819                                  .addReg(MI->getOperand(0).getReg()));
820     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LWZ)
821                                  .addReg(MI->getOperand(1).getReg())
822                                  .addImm(0)
823                                  .addReg(MI->getOperand(0).getReg()));
824     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADD4)
825                                  .addReg(MI->getOperand(0).getReg())
826                                  .addReg(MI->getOperand(1).getReg())
827                                  .addReg(MI->getOperand(0).getReg()));
828     return;
829   }
830   case PPC::PPC32GOT: {
831     MCSymbol *GOTSymbol =
832         OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
833     const MCExpr *SymGotTlsL = MCSymbolRefExpr::create(
834         GOTSymbol, MCSymbolRefExpr::VK_PPC_LO, OutContext);
835     const MCExpr *SymGotTlsHA = MCSymbolRefExpr::create(
836         GOTSymbol, MCSymbolRefExpr::VK_PPC_HA, OutContext);
837     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LI)
838                                  .addReg(MI->getOperand(0).getReg())
839                                  .addExpr(SymGotTlsL));
840     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
841                                  .addReg(MI->getOperand(0).getReg())
842                                  .addReg(MI->getOperand(0).getReg())
843                                  .addExpr(SymGotTlsHA));
844     return;
845   }
846   case PPC::ADDIStlsgdHA: {
847     // Transform: %Xd = ADDIStlsgdHA %X2, <ga:@sym>
848     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
849     assert(Subtarget->isPPC64() && "Not supported for 32-bit PowerPC");
850     const MachineOperand &MO = MI->getOperand(2);
851     const GlobalValue *GValue = MO.getGlobal();
852     MCSymbol *MOSymbol = getSymbol(GValue);
853     const MCExpr *SymGotTlsGD =
854       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA,
855                               OutContext);
856     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
857                                  .addReg(MI->getOperand(0).getReg())
858                                  .addReg(MI->getOperand(1).getReg())
859                                  .addExpr(SymGotTlsGD));
860     return;
861   }
862   case PPC::ADDItlsgdL:
863     // Transform: %Xd = ADDItlsgdL %Xs, <ga:@sym>
864     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsgd@l
865   case PPC::ADDItlsgdL32: {
866     // Transform: %Rd = ADDItlsgdL32 %Rs, <ga:@sym>
867     // Into:      %Rd = ADDI %Rs, sym@got@tlsgd
868     const MachineOperand &MO = MI->getOperand(2);
869     const GlobalValue *GValue = MO.getGlobal();
870     MCSymbol *MOSymbol = getSymbol(GValue);
871     const MCExpr *SymGotTlsGD = MCSymbolRefExpr::create(
872         MOSymbol, Subtarget->isPPC64() ? MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO
873                                        : MCSymbolRefExpr::VK_PPC_GOT_TLSGD,
874         OutContext);
875     EmitToStreamer(*OutStreamer,
876                    MCInstBuilder(Subtarget->isPPC64() ? PPC::ADDI8 : PPC::ADDI)
877                    .addReg(MI->getOperand(0).getReg())
878                    .addReg(MI->getOperand(1).getReg())
879                    .addExpr(SymGotTlsGD));
880     return;
881   }
882   case PPC::GETtlsADDR:
883     // Transform: %X3 = GETtlsADDR %X3, <ga:@sym>
884     // Into: BL8_NOP_TLS __tls_get_addr(sym at tlsgd)
885   case PPC::GETtlsADDR32: {
886     // Transform: %R3 = GETtlsADDR32 %R3, <ga:@sym>
887     // Into: BL_TLS __tls_get_addr(sym at tlsgd)@PLT
888     EmitTlsCall(MI, MCSymbolRefExpr::VK_PPC_TLSGD);
889     return;
890   }
891   case PPC::ADDIStlsldHA: {
892     // Transform: %Xd = ADDIStlsldHA %X2, <ga:@sym>
893     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsld@ha
894     assert(Subtarget->isPPC64() && "Not supported for 32-bit PowerPC");
895     const MachineOperand &MO = MI->getOperand(2);
896     const GlobalValue *GValue = MO.getGlobal();
897     MCSymbol *MOSymbol = getSymbol(GValue);
898     const MCExpr *SymGotTlsLD =
899       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA,
900                               OutContext);
901     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
902                                  .addReg(MI->getOperand(0).getReg())
903                                  .addReg(MI->getOperand(1).getReg())
904                                  .addExpr(SymGotTlsLD));
905     return;
906   }
907   case PPC::ADDItlsldL:
908     // Transform: %Xd = ADDItlsldL %Xs, <ga:@sym>
909     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsld@l
910   case PPC::ADDItlsldL32: {
911     // Transform: %Rd = ADDItlsldL32 %Rs, <ga:@sym>
912     // Into:      %Rd = ADDI %Rs, sym@got@tlsld
913     const MachineOperand &MO = MI->getOperand(2);
914     const GlobalValue *GValue = MO.getGlobal();
915     MCSymbol *MOSymbol = getSymbol(GValue);
916     const MCExpr *SymGotTlsLD = MCSymbolRefExpr::create(
917         MOSymbol, Subtarget->isPPC64() ? MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO
918                                        : MCSymbolRefExpr::VK_PPC_GOT_TLSLD,
919         OutContext);
920     EmitToStreamer(*OutStreamer,
921                    MCInstBuilder(Subtarget->isPPC64() ? PPC::ADDI8 : PPC::ADDI)
922                        .addReg(MI->getOperand(0).getReg())
923                        .addReg(MI->getOperand(1).getReg())
924                        .addExpr(SymGotTlsLD));
925     return;
926   }
927   case PPC::GETtlsldADDR:
928     // Transform: %X3 = GETtlsldADDR %X3, <ga:@sym>
929     // Into: BL8_NOP_TLS __tls_get_addr(sym at tlsld)
930   case PPC::GETtlsldADDR32: {
931     // Transform: %R3 = GETtlsldADDR32 %R3, <ga:@sym>
932     // Into: BL_TLS __tls_get_addr(sym at tlsld)@PLT
933     EmitTlsCall(MI, MCSymbolRefExpr::VK_PPC_TLSLD);
934     return;
935   }
936   case PPC::ADDISdtprelHA:
937     // Transform: %Xd = ADDISdtprelHA %Xs, <ga:@sym>
938     // Into:      %Xd = ADDIS8 %Xs, sym@dtprel@ha
939   case PPC::ADDISdtprelHA32: {
940     // Transform: %Rd = ADDISdtprelHA32 %Rs, <ga:@sym>
941     // Into:      %Rd = ADDIS %Rs, sym@dtprel@ha
942     const MachineOperand &MO = MI->getOperand(2);
943     const GlobalValue *GValue = MO.getGlobal();
944     MCSymbol *MOSymbol = getSymbol(GValue);
945     const MCExpr *SymDtprel =
946       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_HA,
947                               OutContext);
948     EmitToStreamer(
949         *OutStreamer,
950         MCInstBuilder(Subtarget->isPPC64() ? PPC::ADDIS8 : PPC::ADDIS)
951             .addReg(MI->getOperand(0).getReg())
952             .addReg(MI->getOperand(1).getReg())
953             .addExpr(SymDtprel));
954     return;
955   }
956   case PPC::ADDIdtprelL:
957     // Transform: %Xd = ADDIdtprelL %Xs, <ga:@sym>
958     // Into:      %Xd = ADDI8 %Xs, sym@dtprel@l
959   case PPC::ADDIdtprelL32: {
960     // Transform: %Rd = ADDIdtprelL32 %Rs, <ga:@sym>
961     // Into:      %Rd = ADDI %Rs, sym@dtprel@l
962     const MachineOperand &MO = MI->getOperand(2);
963     const GlobalValue *GValue = MO.getGlobal();
964     MCSymbol *MOSymbol = getSymbol(GValue);
965     const MCExpr *SymDtprel =
966       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_LO,
967                               OutContext);
968     EmitToStreamer(*OutStreamer,
969                    MCInstBuilder(Subtarget->isPPC64() ? PPC::ADDI8 : PPC::ADDI)
970                        .addReg(MI->getOperand(0).getReg())
971                        .addReg(MI->getOperand(1).getReg())
972                        .addExpr(SymDtprel));
973     return;
974   }
975   case PPC::MFOCRF:
976   case PPC::MFOCRF8:
977     if (!Subtarget->hasMFOCRF()) {
978       // Transform: %R3 = MFOCRF %CR7
979       // Into:      %R3 = MFCR   ;; cr7
980       unsigned NewOpcode =
981         MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
982       OutStreamer->AddComment(PPCInstPrinter::
983                               getRegisterName(MI->getOperand(1).getReg()));
984       EmitToStreamer(*OutStreamer, MCInstBuilder(NewOpcode)
985                                   .addReg(MI->getOperand(0).getReg()));
986       return;
987     }
988     break;
989   case PPC::MTOCRF:
990   case PPC::MTOCRF8:
991     if (!Subtarget->hasMFOCRF()) {
992       // Transform: %CR7 = MTOCRF %R3
993       // Into:      MTCRF mask, %R3 ;; cr7
994       unsigned NewOpcode =
995         MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
996       unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
997                               ->getEncodingValue(MI->getOperand(0).getReg());
998       OutStreamer->AddComment(PPCInstPrinter::
999                               getRegisterName(MI->getOperand(0).getReg()));
1000       EmitToStreamer(*OutStreamer, MCInstBuilder(NewOpcode)
1001                                      .addImm(Mask)
1002                                      .addReg(MI->getOperand(1).getReg()));
1003       return;
1004     }
1005     break;
1006   case PPC::LD:
1007   case PPC::STD:
1008   case PPC::LWA_32:
1009   case PPC::LWA: {
1010     // Verify alignment is legal, so we don't create relocations
1011     // that can't be supported.
1012     // FIXME:  This test is currently disabled for Darwin.  The test
1013     // suite shows a handful of test cases that fail this check for
1014     // Darwin.  Those need to be investigated before this sanity test
1015     // can be enabled for those subtargets.
1016     if (!Subtarget->isDarwin()) {
1017       unsigned OpNum = (MI->getOpcode() == PPC::STD) ? 2 : 1;
1018       const MachineOperand &MO = MI->getOperand(OpNum);
1019       if (MO.isGlobal() && MO.getGlobal()->getAlignment() < 4)
1020         llvm_unreachable("Global must be word-aligned for LD, STD, LWA!");
1021     }
1022     // Now process the instruction normally.
1023     break;
1024   }
1025   }
1026 
1027   LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
1028   EmitToStreamer(*OutStreamer, TmpInst);
1029 }
1030 
EmitStartOfAsmFile(Module & M)1031 void PPCLinuxAsmPrinter::EmitStartOfAsmFile(Module &M) {
1032   if (static_cast<const PPCTargetMachine &>(TM).isELFv2ABI()) {
1033     PPCTargetStreamer *TS =
1034       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1035 
1036     if (TS)
1037       TS->emitAbiVersion(2);
1038   }
1039 
1040   if (static_cast<const PPCTargetMachine &>(TM).isPPC64() ||
1041       TM.getRelocationModel() != Reloc::PIC_)
1042     return AsmPrinter::EmitStartOfAsmFile(M);
1043 
1044   if (M.getPICLevel() == PICLevel::Small)
1045     return AsmPrinter::EmitStartOfAsmFile(M);
1046 
1047   OutStreamer->SwitchSection(OutContext.getELFSection(
1048       ".got2", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC));
1049 
1050   MCSymbol *TOCSym = OutContext.getOrCreateSymbol(Twine(".LTOC"));
1051   MCSymbol *CurrentPos = OutContext.createTempSymbol();
1052 
1053   OutStreamer->EmitLabel(CurrentPos);
1054 
1055   // The GOT pointer points to the middle of the GOT, in order to reference the
1056   // entire 64kB range.  0x8000 is the midpoint.
1057   const MCExpr *tocExpr =
1058     MCBinaryExpr::createAdd(MCSymbolRefExpr::create(CurrentPos, OutContext),
1059                             MCConstantExpr::create(0x8000, OutContext),
1060                             OutContext);
1061 
1062   OutStreamer->EmitAssignment(TOCSym, tocExpr);
1063 
1064   OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
1065 }
1066 
EmitFunctionEntryLabel()1067 void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
1068   // linux/ppc32 - Normal entry label.
1069   if (!Subtarget->isPPC64() &&
1070       (TM.getRelocationModel() != Reloc::PIC_ ||
1071        MF->getFunction()->getParent()->getPICLevel() == PICLevel::Small))
1072     return AsmPrinter::EmitFunctionEntryLabel();
1073 
1074   if (!Subtarget->isPPC64()) {
1075     const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
1076     if (PPCFI->usesPICBase()) {
1077       MCSymbol *RelocSymbol = PPCFI->getPICOffsetSymbol();
1078       MCSymbol *PICBase = MF->getPICBaseSymbol();
1079       OutStreamer->EmitLabel(RelocSymbol);
1080 
1081       const MCExpr *OffsExpr =
1082         MCBinaryExpr::createSub(
1083           MCSymbolRefExpr::create(OutContext.getOrCreateSymbol(Twine(".LTOC")),
1084                                                                OutContext),
1085                                   MCSymbolRefExpr::create(PICBase, OutContext),
1086           OutContext);
1087       OutStreamer->EmitValue(OffsExpr, 4);
1088       OutStreamer->EmitLabel(CurrentFnSym);
1089       return;
1090     } else
1091       return AsmPrinter::EmitFunctionEntryLabel();
1092   }
1093 
1094   // ELFv2 ABI - Normal entry label.
1095   if (Subtarget->isELFv2ABI())
1096     return AsmPrinter::EmitFunctionEntryLabel();
1097 
1098   // Emit an official procedure descriptor.
1099   MCSectionSubPair Current = OutStreamer->getCurrentSection();
1100   MCSectionELF *Section = OutStreamer->getContext().getELFSection(
1101       ".opd", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1102   OutStreamer->SwitchSection(Section);
1103   OutStreamer->EmitLabel(CurrentFnSym);
1104   OutStreamer->EmitValueToAlignment(8);
1105   MCSymbol *Symbol1 = CurrentFnSymForSize;
1106   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
1107   // entry point.
1108   OutStreamer->EmitValue(MCSymbolRefExpr::create(Symbol1, OutContext),
1109                          8 /*size*/);
1110   MCSymbol *Symbol2 = OutContext.getOrCreateSymbol(StringRef(".TOC."));
1111   // Generates a R_PPC64_TOC relocation for TOC base insertion.
1112   OutStreamer->EmitValue(
1113     MCSymbolRefExpr::create(Symbol2, MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
1114     8/*size*/);
1115   // Emit a null environment pointer.
1116   OutStreamer->EmitIntValue(0, 8 /* size */);
1117   OutStreamer->SwitchSection(Current.first, Current.second);
1118 }
1119 
doFinalization(Module & M)1120 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
1121   const DataLayout &DL = getDataLayout();
1122 
1123   bool isPPC64 = DL.getPointerSizeInBits() == 64;
1124 
1125   PPCTargetStreamer &TS =
1126       static_cast<PPCTargetStreamer &>(*OutStreamer->getTargetStreamer());
1127 
1128   if (!TOC.empty()) {
1129     MCSectionELF *Section;
1130 
1131     if (isPPC64)
1132       Section = OutStreamer->getContext().getELFSection(
1133           ".toc", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1134         else
1135           Section = OutStreamer->getContext().getELFSection(
1136               ".got2", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1137     OutStreamer->SwitchSection(Section);
1138 
1139     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
1140          E = TOC.end(); I != E; ++I) {
1141       OutStreamer->EmitLabel(I->second);
1142       MCSymbol *S = I->first;
1143       if (isPPC64)
1144         TS.emitTCEntry(*S);
1145       else
1146         OutStreamer->EmitSymbolValue(S, 4);
1147     }
1148   }
1149 
1150   return AsmPrinter::doFinalization(M);
1151 }
1152 
1153 /// EmitFunctionBodyStart - Emit a global entry point prefix for ELFv2.
EmitFunctionBodyStart()1154 void PPCLinuxAsmPrinter::EmitFunctionBodyStart() {
1155   // In the ELFv2 ABI, in functions that use the TOC register, we need to
1156   // provide two entry points.  The ABI guarantees that when calling the
1157   // local entry point, r2 is set up by the caller to contain the TOC base
1158   // for this function, and when calling the global entry point, r12 is set
1159   // up by the caller to hold the address of the global entry point.  We
1160   // thus emit a prefix sequence along the following lines:
1161   //
1162   // func:
1163   //         # global entry point
1164   //         addis r2,r12,(.TOC.-func)@ha
1165   //         addi  r2,r2,(.TOC.-func)@l
1166   //         .localentry func, .-func
1167   //         # local entry point, followed by function body
1168   //
1169   // This ensures we have r2 set up correctly while executing the function
1170   // body, no matter which entry point is called.
1171   if (Subtarget->isELFv2ABI()
1172       // Only do all that if the function uses r2 in the first place.
1173       && !MF->getRegInfo().use_empty(PPC::X2)) {
1174 
1175     MCSymbol *GlobalEntryLabel = OutContext.createTempSymbol();
1176     OutStreamer->EmitLabel(GlobalEntryLabel);
1177     const MCSymbolRefExpr *GlobalEntryLabelExp =
1178       MCSymbolRefExpr::create(GlobalEntryLabel, OutContext);
1179 
1180     MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(StringRef(".TOC."));
1181     const MCExpr *TOCDeltaExpr =
1182       MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
1183                               GlobalEntryLabelExp, OutContext);
1184 
1185     const MCExpr *TOCDeltaHi =
1186       PPCMCExpr::createHa(TOCDeltaExpr, false, OutContext);
1187     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
1188                                  .addReg(PPC::X2)
1189                                  .addReg(PPC::X12)
1190                                  .addExpr(TOCDeltaHi));
1191 
1192     const MCExpr *TOCDeltaLo =
1193       PPCMCExpr::createLo(TOCDeltaExpr, false, OutContext);
1194     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDI)
1195                                  .addReg(PPC::X2)
1196                                  .addReg(PPC::X2)
1197                                  .addExpr(TOCDeltaLo));
1198 
1199     MCSymbol *LocalEntryLabel = OutContext.createTempSymbol();
1200     OutStreamer->EmitLabel(LocalEntryLabel);
1201     const MCSymbolRefExpr *LocalEntryLabelExp =
1202        MCSymbolRefExpr::create(LocalEntryLabel, OutContext);
1203     const MCExpr *LocalOffsetExp =
1204       MCBinaryExpr::createSub(LocalEntryLabelExp,
1205                               GlobalEntryLabelExp, OutContext);
1206 
1207     PPCTargetStreamer *TS =
1208       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1209 
1210     if (TS)
1211       TS->emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym), LocalOffsetExp);
1212   }
1213 }
1214 
1215 /// EmitFunctionBodyEnd - Print the traceback table before the .size
1216 /// directive.
1217 ///
EmitFunctionBodyEnd()1218 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
1219   // Only the 64-bit target requires a traceback table.  For now,
1220   // we only emit the word of zeroes that GDB requires to find
1221   // the end of the function, and zeroes for the eight-byte
1222   // mandatory fields.
1223   // FIXME: We should fill in the eight-byte mandatory fields as described in
1224   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
1225   // currently make use of these fields).
1226   if (Subtarget->isPPC64()) {
1227     OutStreamer->EmitIntValue(0, 4/*size*/);
1228     OutStreamer->EmitIntValue(0, 8/*size*/);
1229   }
1230 }
1231 
EmitStartOfAsmFile(Module & M)1232 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
1233   static const char *const CPUDirectives[] = {
1234     "",
1235     "ppc",
1236     "ppc440",
1237     "ppc601",
1238     "ppc602",
1239     "ppc603",
1240     "ppc7400",
1241     "ppc750",
1242     "ppc970",
1243     "ppcA2",
1244     "ppce500mc",
1245     "ppce5500",
1246     "power3",
1247     "power4",
1248     "power5",
1249     "power5x",
1250     "power6",
1251     "power6x",
1252     "power7",
1253     "ppc64",
1254     "ppc64le"
1255   };
1256 
1257   // Get the numerically largest directive.
1258   // FIXME: How should we merge darwin directives?
1259   unsigned Directive = PPC::DIR_NONE;
1260   for (const Function &F : M) {
1261     const PPCSubtarget &STI = TM.getSubtarget<PPCSubtarget>(F);
1262     unsigned FDir = STI.getDarwinDirective();
1263     Directive = Directive > FDir ? FDir : STI.getDarwinDirective();
1264     if (STI.hasMFOCRF() && Directive < PPC::DIR_970)
1265       Directive = PPC::DIR_970;
1266     if (STI.hasAltivec() && Directive < PPC::DIR_7400)
1267       Directive = PPC::DIR_7400;
1268     if (STI.isPPC64() && Directive < PPC::DIR_64)
1269       Directive = PPC::DIR_64;
1270   }
1271 
1272   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
1273 
1274   assert(Directive < array_lengthof(CPUDirectives) &&
1275          "CPUDirectives[] might not be up-to-date!");
1276   PPCTargetStreamer &TStreamer =
1277       *static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1278   TStreamer.emitMachine(CPUDirectives[Directive]);
1279 
1280   // Prime text sections so they are adjacent.  This reduces the likelihood a
1281   // large data or debug section causes a branch to exceed 16M limit.
1282   const TargetLoweringObjectFileMachO &TLOFMacho =
1283       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1284   OutStreamer->SwitchSection(TLOFMacho.getTextCoalSection());
1285   if (TM.getRelocationModel() == Reloc::PIC_) {
1286     OutStreamer->SwitchSection(
1287            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
1288                                       MachO::S_SYMBOL_STUBS |
1289                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1290                                       32, SectionKind::getText()));
1291   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
1292     OutStreamer->SwitchSection(
1293            OutContext.getMachOSection("__TEXT","__symbol_stub1",
1294                                       MachO::S_SYMBOL_STUBS |
1295                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1296                                       16, SectionKind::getText()));
1297   }
1298   OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
1299 }
1300 
GetLazyPtr(MCSymbol * Sym,MCContext & Ctx)1301 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
1302   // Remove $stub suffix, add $lazy_ptr.
1303   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
1304   return Ctx.getOrCreateSymbol(NoStub + "$lazy_ptr");
1305 }
1306 
GetAnonSym(MCSymbol * Sym,MCContext & Ctx)1307 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
1308   // Add $tmp suffix to $stub, yielding $stub$tmp.
1309   return Ctx.getOrCreateSymbol(Sym->getName() + "$tmp");
1310 }
1311 
1312 void PPCDarwinAsmPrinter::
EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy & Stubs)1313 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
1314   bool isPPC64 = getDataLayout().getPointerSizeInBits() == 64;
1315 
1316   // Construct a local MCSubtargetInfo and shadow EmitToStreamer here.
1317   // This is because the MachineFunction won't exist (but have not yet been
1318   // freed) and since we're at the global level we can use the default
1319   // constructed subtarget.
1320   std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
1321       TM.getTargetTriple().str(), TM.getTargetCPU(),
1322       TM.getTargetFeatureString()));
1323   auto EmitToStreamer = [&STI] (MCStreamer &S, const MCInst &Inst) {
1324     S.EmitInstruction(Inst, *STI);
1325   };
1326 
1327   const TargetLoweringObjectFileMachO &TLOFMacho =
1328       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1329 
1330   // .lazy_symbol_pointer
1331   MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
1332 
1333   // Output stubs for dynamically-linked functions
1334   if (TM.getRelocationModel() == Reloc::PIC_) {
1335     MCSection *StubSection = OutContext.getMachOSection(
1336         "__TEXT", "__picsymbolstub1",
1337         MachO::S_SYMBOL_STUBS | MachO::S_ATTR_PURE_INSTRUCTIONS, 32,
1338         SectionKind::getText());
1339     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1340       OutStreamer->SwitchSection(StubSection);
1341       EmitAlignment(4);
1342 
1343       MCSymbol *Stub = Stubs[i].first;
1344       MCSymbol *RawSym = Stubs[i].second.getPointer();
1345       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1346       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
1347 
1348       OutStreamer->EmitLabel(Stub);
1349       OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1350 
1351       const MCExpr *Anon = MCSymbolRefExpr::create(AnonSymbol, OutContext);
1352       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::create(LazyPtr, OutContext);
1353       const MCExpr *Sub =
1354         MCBinaryExpr::createSub(LazyPtrExpr, Anon, OutContext);
1355 
1356       // mflr r0
1357       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
1358       // bcl 20, 31, AnonSymbol
1359       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCLalways).addExpr(Anon));
1360       OutStreamer->EmitLabel(AnonSymbol);
1361       // mflr r11
1362       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
1363       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
1364       const MCExpr *SubHa16 = PPCMCExpr::createHa(Sub, true, OutContext);
1365       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
1366         .addReg(PPC::R11)
1367         .addReg(PPC::R11)
1368         .addExpr(SubHa16));
1369       // mtlr r0
1370       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
1371 
1372       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
1373       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
1374       const MCExpr *SubLo16 = PPCMCExpr::createLo(Sub, true, OutContext);
1375       EmitToStreamer(*OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1376         .addReg(PPC::R12)
1377         .addExpr(SubLo16).addExpr(SubLo16)
1378         .addReg(PPC::R11));
1379       // mtctr r12
1380       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1381       // bctr
1382       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTR));
1383 
1384       OutStreamer->SwitchSection(LSPSection);
1385       OutStreamer->EmitLabel(LazyPtr);
1386       OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1387 
1388       MCSymbol *DyldStubBindingHelper =
1389         OutContext.getOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1390       if (isPPC64) {
1391         // .quad dyld_stub_binding_helper
1392         OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 8);
1393       } else {
1394         // .long dyld_stub_binding_helper
1395         OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 4);
1396       }
1397     }
1398     OutStreamer->AddBlankLine();
1399     return;
1400   }
1401 
1402   MCSection *StubSection = OutContext.getMachOSection(
1403       "__TEXT", "__symbol_stub1",
1404       MachO::S_SYMBOL_STUBS | MachO::S_ATTR_PURE_INSTRUCTIONS, 16,
1405       SectionKind::getText());
1406   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1407     MCSymbol *Stub = Stubs[i].first;
1408     MCSymbol *RawSym = Stubs[i].second.getPointer();
1409     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1410     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::create(LazyPtr, OutContext);
1411 
1412     OutStreamer->SwitchSection(StubSection);
1413     EmitAlignment(4);
1414     OutStreamer->EmitLabel(Stub);
1415     OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1416 
1417     // lis r11, ha16(LazyPtr)
1418     const MCExpr *LazyPtrHa16 =
1419       PPCMCExpr::createHa(LazyPtrExpr, true, OutContext);
1420     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LIS)
1421       .addReg(PPC::R11)
1422       .addExpr(LazyPtrHa16));
1423 
1424     // ldu r12, lo16(LazyPtr)(r11)
1425     // lwzu r12, lo16(LazyPtr)(r11)
1426     const MCExpr *LazyPtrLo16 =
1427       PPCMCExpr::createLo(LazyPtrExpr, true, OutContext);
1428     EmitToStreamer(*OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1429       .addReg(PPC::R12)
1430       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
1431       .addReg(PPC::R11));
1432 
1433     // mtctr r12
1434     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1435     // bctr
1436     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTR));
1437 
1438     OutStreamer->SwitchSection(LSPSection);
1439     OutStreamer->EmitLabel(LazyPtr);
1440     OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1441 
1442     MCSymbol *DyldStubBindingHelper =
1443       OutContext.getOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1444     if (isPPC64) {
1445       // .quad dyld_stub_binding_helper
1446       OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 8);
1447     } else {
1448       // .long dyld_stub_binding_helper
1449       OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 4);
1450     }
1451   }
1452 
1453   OutStreamer->AddBlankLine();
1454 }
1455 
doFinalization(Module & M)1456 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1457   bool isPPC64 = getDataLayout().getPointerSizeInBits() == 64;
1458 
1459   // Darwin/PPC always uses mach-o.
1460   const TargetLoweringObjectFileMachO &TLOFMacho =
1461       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1462   MachineModuleInfoMachO &MMIMacho =
1463       MMI->getObjFileInfo<MachineModuleInfoMachO>();
1464 
1465   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1466   if (!Stubs.empty())
1467     EmitFunctionStubs(Stubs);
1468 
1469   if (MAI->doesSupportExceptionHandling() && MMI) {
1470     // Add the (possibly multiple) personalities to the set of global values.
1471     // Only referenced functions get into the Personalities list.
1472     for (const Function *Personality : MMI->getPersonalities()) {
1473       if (Personality) {
1474         MCSymbol *NLPSym =
1475             getSymbolWithGlobalValueBase(Personality, "$non_lazy_ptr");
1476         MachineModuleInfoImpl::StubValueTy &StubSym =
1477             MMIMacho.getGVStubEntry(NLPSym);
1478         StubSym =
1479             MachineModuleInfoImpl::StubValueTy(getSymbol(Personality), true);
1480       }
1481     }
1482   }
1483 
1484   // Output stubs for dynamically-linked functions.
1485   Stubs = MMIMacho.GetGVStubList();
1486 
1487   // Output macho stubs for external and common global variables.
1488   if (!Stubs.empty()) {
1489     // Switch with ".non_lazy_symbol_pointer" directive.
1490     OutStreamer->SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1491     EmitAlignment(isPPC64 ? 3 : 2);
1492 
1493     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1494       // L_foo$stub:
1495       OutStreamer->EmitLabel(Stubs[i].first);
1496       //   .indirect_symbol _foo
1497       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1498       OutStreamer->EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1499 
1500       if (MCSym.getInt())
1501         // External to current translation unit.
1502         OutStreamer->EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1503       else
1504         // Internal to current translation unit.
1505         //
1506         // When we place the LSDA into the TEXT section, the type info pointers
1507         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1508         // However, sometimes the types are local to the file. So we need to
1509         // fill in the value for the NLP in those cases.
1510         OutStreamer->EmitValue(MCSymbolRefExpr::create(MCSym.getPointer(),
1511                                                        OutContext),
1512                               isPPC64 ? 8 : 4/*size*/);
1513     }
1514 
1515     Stubs.clear();
1516     OutStreamer->AddBlankLine();
1517   }
1518 
1519   Stubs = MMIMacho.GetHiddenGVStubList();
1520   if (!Stubs.empty()) {
1521     OutStreamer->SwitchSection(getObjFileLowering().getDataSection());
1522     EmitAlignment(isPPC64 ? 3 : 2);
1523 
1524     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1525       // L_foo$stub:
1526       OutStreamer->EmitLabel(Stubs[i].first);
1527       //   .long _foo
1528       OutStreamer->EmitValue(MCSymbolRefExpr::
1529                              create(Stubs[i].second.getPointer(),
1530                                     OutContext),
1531                              isPPC64 ? 8 : 4/*size*/);
1532     }
1533 
1534     Stubs.clear();
1535     OutStreamer->AddBlankLine();
1536   }
1537 
1538   // Funny Darwin hack: This flag tells the linker that no global symbols
1539   // contain code that falls through to other global symbols (e.g. the obvious
1540   // implementation of multiple entry points).  If this doesn't occur, the
1541   // linker can safely perform dead code stripping.  Since LLVM never generates
1542   // code that does this, it is always safe to set.
1543   OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1544 
1545   return AsmPrinter::doFinalization(M);
1546 }
1547 
1548 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1549 /// for a MachineFunction to the given output stream, in a format that the
1550 /// Darwin assembler can deal with.
1551 ///
1552 static AsmPrinter *
createPPCAsmPrinterPass(TargetMachine & tm,std::unique_ptr<MCStreamer> && Streamer)1553 createPPCAsmPrinterPass(TargetMachine &tm,
1554                         std::unique_ptr<MCStreamer> &&Streamer) {
1555   if (tm.getTargetTriple().isMacOSX())
1556     return new PPCDarwinAsmPrinter(tm, std::move(Streamer));
1557   return new PPCLinuxAsmPrinter(tm, std::move(Streamer));
1558 }
1559 
1560 // Force static initialization.
LLVMInitializePowerPCAsmPrinter()1561 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1562   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1563   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1564   TargetRegistry::RegisterAsmPrinter(ThePPC64LETarget, createPPCAsmPrinterPass);
1565 }
1566