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