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