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     void EmitInstruction(const MachineInstr *MI) override;
86 
87     void printOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
88 
89     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
90                          unsigned AsmVariant, const char *ExtraCode,
91                          raw_ostream &O) override;
92     bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
93                                unsigned AsmVariant, const char *ExtraCode,
94                                raw_ostream &O) override;
95 
96     void EmitEndOfAsmFile(Module &M) override;
97 
98     void LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM,
99                        const MachineInstr &MI);
100     void LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM,
101                          const MachineInstr &MI);
102     void EmitTlsCall(const MachineInstr *MI, MCSymbolRefExpr::VariantKind VK);
103     bool runOnMachineFunction(MachineFunction &MF) override {
104       Subtarget = &MF.getSubtarget<PPCSubtarget>();
105       return AsmPrinter::runOnMachineFunction(MF);
106     }
107   };
108 
109   /// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux
110   class PPCLinuxAsmPrinter : public PPCAsmPrinter {
111   public:
112     explicit PPCLinuxAsmPrinter(TargetMachine &TM,
113                                 std::unique_ptr<MCStreamer> Streamer)
114         : PPCAsmPrinter(TM, std::move(Streamer)) {}
115 
116     const char *getPassName() const override {
117       return "Linux PPC Assembly Printer";
118     }
119 
120     bool doFinalization(Module &M) override;
121     void EmitStartOfAsmFile(Module &M) override;
122 
123     void EmitFunctionEntryLabel() override;
124 
125     void EmitFunctionBodyStart() override;
126     void EmitFunctionBodyEnd() override;
127   };
128 
129   /// PPCDarwinAsmPrinter - PowerPC assembly printer, customized for Darwin/Mac
130   /// OS X
131   class PPCDarwinAsmPrinter : public PPCAsmPrinter {
132   public:
133     explicit PPCDarwinAsmPrinter(TargetMachine &TM,
134                                  std::unique_ptr<MCStreamer> Streamer)
135         : PPCAsmPrinter(TM, std::move(Streamer)) {}
136 
137     const char *getPassName() const override {
138       return "Darwin PPC Assembly Printer";
139     }
140 
141     bool doFinalization(Module &M) override;
142     void EmitStartOfAsmFile(Module &M) override;
143 
144     void EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs);
145   };
146 } // end of anonymous namespace
147 
148 /// stripRegisterPrefix - This method strips the character prefix from a
149 /// register name so that only the number is left.  Used by for linux asm.
150 static const char *stripRegisterPrefix(const char *RegName) {
151   switch (RegName[0]) {
152     case 'r':
153     case 'f':
154     case 'q': // for QPX
155     case 'v':
156       if (RegName[1] == 's')
157         return RegName + 2;
158       return RegName + 1;
159     case 'c': if (RegName[1] == 'r') return RegName + 2;
160   }
161 
162   return RegName;
163 }
164 
165 void PPCAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
166                                  raw_ostream &O) {
167   const DataLayout &DL = getDataLayout();
168   const MachineOperand &MO = MI->getOperand(OpNo);
169 
170   switch (MO.getType()) {
171   case MachineOperand::MO_Register: {
172     const char *RegName = PPCInstPrinter::getRegisterName(MO.getReg());
173     // Linux assembler (Others?) does not take register mnemonics.
174     // FIXME - What about special registers used in mfspr/mtspr?
175     if (!Subtarget->isDarwin())
176       RegName = stripRegisterPrefix(RegName);
177     O << RegName;
178     return;
179   }
180   case MachineOperand::MO_Immediate:
181     O << MO.getImm();
182     return;
183 
184   case MachineOperand::MO_MachineBasicBlock:
185     MO.getMBB()->getSymbol()->print(O, MAI);
186     return;
187   case MachineOperand::MO_ConstantPoolIndex:
188     O << DL.getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
189       << MO.getIndex();
190     return;
191   case MachineOperand::MO_BlockAddress:
192     GetBlockAddressSymbol(MO.getBlockAddress())->print(O, MAI);
193     return;
194   case MachineOperand::MO_GlobalAddress: {
195     // Computing the address of a global symbol, not calling it.
196     const GlobalValue *GV = MO.getGlobal();
197     MCSymbol *SymToPrint;
198 
199     // External or weakly linked global variables need non-lazily-resolved stubs
200     if (TM.getRelocationModel() != Reloc::Static &&
201         !GV->isStrongDefinitionForLinker()) {
202       if (!GV->hasHiddenVisibility()) {
203         SymToPrint = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
204         MachineModuleInfoImpl::StubValueTy &StubSym =
205             MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(
206                 SymToPrint);
207         if (!StubSym.getPointer())
208           StubSym = MachineModuleInfoImpl::
209             StubValueTy(getSymbol(GV), !GV->hasInternalLinkage());
210       } else if (GV->isDeclaration() || GV->hasCommonLinkage() ||
211                  GV->hasAvailableExternallyLinkage()) {
212         SymToPrint = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
213 
214         MachineModuleInfoImpl::StubValueTy &StubSym =
215             MMI->getObjFileInfo<MachineModuleInfoMachO>().getHiddenGVStubEntry(
216                 SymToPrint);
217         if (!StubSym.getPointer())
218           StubSym = MachineModuleInfoImpl::
219             StubValueTy(getSymbol(GV), !GV->hasInternalLinkage());
220       } else {
221         SymToPrint = getSymbol(GV);
222       }
223     } else {
224       SymToPrint = getSymbol(GV);
225     }
226 
227     SymToPrint->print(O, MAI);
228 
229     printOffset(MO.getOffset(), O);
230     return;
231   }
232 
233   default:
234     O << "<unknown operand type: " << (unsigned)MO.getType() << ">";
235     return;
236   }
237 }
238 
239 /// PrintAsmOperand - Print out an operand for an inline asm expression.
240 ///
241 bool PPCAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
242                                     unsigned AsmVariant,
243                                     const char *ExtraCode, raw_ostream &O) {
244   // Does this asm operand have a single letter operand modifier?
245   if (ExtraCode && ExtraCode[0]) {
246     if (ExtraCode[1] != 0) return true; // Unknown modifier.
247 
248     switch (ExtraCode[0]) {
249     default:
250       // See if this is a generic print operand
251       return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O);
252     case 'c': // Don't print "$" before a global var name or constant.
253       break; // PPC never has a prefix.
254     case 'L': // Write second word of DImode reference.
255       // Verify that this operand has two consecutive registers.
256       if (!MI->getOperand(OpNo).isReg() ||
257           OpNo+1 == MI->getNumOperands() ||
258           !MI->getOperand(OpNo+1).isReg())
259         return true;
260       ++OpNo;   // Return the high-part.
261       break;
262     case 'I':
263       // Write 'i' if an integer constant, otherwise nothing.  Used to print
264       // addi vs add, etc.
265       if (MI->getOperand(OpNo).isImm())
266         O << "i";
267       return false;
268     }
269   }
270 
271   printOperand(MI, OpNo, O);
272   return false;
273 }
274 
275 // At the moment, all inline asm memory operands are a single register.
276 // In any case, the output of this routine should always be just one
277 // assembler operand.
278 
279 bool PPCAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
280                                           unsigned AsmVariant,
281                                           const char *ExtraCode,
282                                           raw_ostream &O) {
283   if (ExtraCode && ExtraCode[0]) {
284     if (ExtraCode[1] != 0) return true; // Unknown modifier.
285 
286     switch (ExtraCode[0]) {
287     default: return true;  // Unknown modifier.
288     case 'y': // A memory reference for an X-form instruction
289       {
290         const char *RegName = "r0";
291         if (!Subtarget->isDarwin())
292           RegName = stripRegisterPrefix(RegName);
293         O << RegName << ", ";
294         printOperand(MI, OpNo, O);
295         return false;
296       }
297     case 'U': // Print 'u' for update form.
298     case 'X': // Print 'x' for indexed form.
299     {
300       // FIXME: Currently for PowerPC memory operands are always loaded
301       // into a register, so we never get an update or indexed form.
302       // This is bad even for offset forms, since even if we know we
303       // have a value in -16(r1), we will generate a load into r<n>
304       // and then load from 0(r<n>).  Until that issue is fixed,
305       // tolerate 'U' and 'X' but don't output anything.
306       assert(MI->getOperand(OpNo).isReg());
307       return false;
308     }
309     }
310   }
311 
312   assert(MI->getOperand(OpNo).isReg());
313   O << "0(";
314   printOperand(MI, OpNo, O);
315   O << ")";
316   return false;
317 }
318 
319 /// lookUpOrCreateTOCEntry -- Given a symbol, look up whether a TOC entry
320 /// exists for it.  If not, create one.  Then return a symbol that references
321 /// the TOC entry.
322 MCSymbol *PPCAsmPrinter::lookUpOrCreateTOCEntry(MCSymbol *Sym) {
323   MCSymbol *&TOCEntry = TOC[Sym];
324   if (!TOCEntry)
325     TOCEntry = createTempSymbol("C");
326   return TOCEntry;
327 }
328 
329 void PPCAsmPrinter::EmitEndOfAsmFile(Module &M) {
330   SM.serializeToStackMapSection();
331 }
332 
333 void PPCAsmPrinter::LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM,
334                                   const MachineInstr &MI) {
335   unsigned NumNOPBytes = MI.getOperand(1).getImm();
336 
337   SM.recordStackMap(MI);
338   assert(NumNOPBytes % 4 == 0 && "Invalid number of NOP bytes requested!");
339 
340   // Scan ahead to trim the shadow.
341   const MachineBasicBlock &MBB = *MI.getParent();
342   MachineBasicBlock::const_iterator MII(MI);
343   ++MII;
344   while (NumNOPBytes > 0) {
345     if (MII == MBB.end() || MII->isCall() ||
346         MII->getOpcode() == PPC::DBG_VALUE ||
347         MII->getOpcode() == TargetOpcode::PATCHPOINT ||
348         MII->getOpcode() == TargetOpcode::STACKMAP)
349       break;
350     ++MII;
351     NumNOPBytes -= 4;
352   }
353 
354   // Emit nops.
355   for (unsigned i = 0; i < NumNOPBytes; i += 4)
356     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::NOP));
357 }
358 
359 // Lower a patchpoint of the form:
360 // [<def>], <id>, <numBytes>, <target>, <numArgs>
361 void PPCAsmPrinter::LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM,
362                                     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(*OutStreamer, SM, *MI);
509   case TargetOpcode::PATCHPOINT:
510     return LowerPATCHPOINT(*OutStreamer, 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     return AsmPrinter::EmitFunctionEntryLabel();
1101 
1102   // Emit an official procedure descriptor.
1103   MCSectionSubPair Current = OutStreamer->getCurrentSection();
1104   MCSectionELF *Section = OutStreamer->getContext().getELFSection(
1105       ".opd", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1106   OutStreamer->SwitchSection(Section);
1107   OutStreamer->EmitLabel(CurrentFnSym);
1108   OutStreamer->EmitValueToAlignment(8);
1109   MCSymbol *Symbol1 = CurrentFnSymForSize;
1110   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
1111   // entry point.
1112   OutStreamer->EmitValue(MCSymbolRefExpr::create(Symbol1, OutContext),
1113                          8 /*size*/);
1114   MCSymbol *Symbol2 = OutContext.getOrCreateSymbol(StringRef(".TOC."));
1115   // Generates a R_PPC64_TOC relocation for TOC base insertion.
1116   OutStreamer->EmitValue(
1117     MCSymbolRefExpr::create(Symbol2, MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
1118     8/*size*/);
1119   // Emit a null environment pointer.
1120   OutStreamer->EmitIntValue(0, 8 /* size */);
1121   OutStreamer->SwitchSection(Current.first, Current.second);
1122 }
1123 
1124 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
1125   const DataLayout &DL = getDataLayout();
1126 
1127   bool isPPC64 = DL.getPointerSizeInBits() == 64;
1128 
1129   PPCTargetStreamer &TS =
1130       static_cast<PPCTargetStreamer &>(*OutStreamer->getTargetStreamer());
1131 
1132   if (!TOC.empty()) {
1133     MCSectionELF *Section;
1134 
1135     if (isPPC64)
1136       Section = OutStreamer->getContext().getELFSection(
1137           ".toc", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1138         else
1139           Section = OutStreamer->getContext().getELFSection(
1140               ".got2", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1141     OutStreamer->SwitchSection(Section);
1142 
1143     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
1144          E = TOC.end(); I != E; ++I) {
1145       OutStreamer->EmitLabel(I->second);
1146       MCSymbol *S = I->first;
1147       if (isPPC64)
1148         TS.emitTCEntry(*S);
1149       else
1150         OutStreamer->EmitSymbolValue(S, 4);
1151     }
1152   }
1153 
1154   return AsmPrinter::doFinalization(M);
1155 }
1156 
1157 /// EmitFunctionBodyStart - Emit a global entry point prefix for ELFv2.
1158 void PPCLinuxAsmPrinter::EmitFunctionBodyStart() {
1159   // In the ELFv2 ABI, in functions that use the TOC register, we need to
1160   // provide two entry points.  The ABI guarantees that when calling the
1161   // local entry point, r2 is set up by the caller to contain the TOC base
1162   // for this function, and when calling the global entry point, r12 is set
1163   // up by the caller to hold the address of the global entry point.  We
1164   // thus emit a prefix sequence along the following lines:
1165   //
1166   // func:
1167   //         # global entry point
1168   //         addis r2,r12,(.TOC.-func)@ha
1169   //         addi  r2,r2,(.TOC.-func)@l
1170   //         .localentry func, .-func
1171   //         # local entry point, followed by function body
1172   //
1173   // This ensures we have r2 set up correctly while executing the function
1174   // body, no matter which entry point is called.
1175   if (Subtarget->isELFv2ABI()
1176       // Only do all that if the function uses r2 in the first place.
1177       && !MF->getRegInfo().use_empty(PPC::X2)) {
1178 
1179     MCSymbol *GlobalEntryLabel = OutContext.createTempSymbol();
1180     OutStreamer->EmitLabel(GlobalEntryLabel);
1181     const MCSymbolRefExpr *GlobalEntryLabelExp =
1182       MCSymbolRefExpr::create(GlobalEntryLabel, OutContext);
1183 
1184     MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(StringRef(".TOC."));
1185     const MCExpr *TOCDeltaExpr =
1186       MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
1187                               GlobalEntryLabelExp, OutContext);
1188 
1189     const MCExpr *TOCDeltaHi =
1190       PPCMCExpr::createHa(TOCDeltaExpr, false, OutContext);
1191     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
1192                                  .addReg(PPC::X2)
1193                                  .addReg(PPC::X12)
1194                                  .addExpr(TOCDeltaHi));
1195 
1196     const MCExpr *TOCDeltaLo =
1197       PPCMCExpr::createLo(TOCDeltaExpr, false, OutContext);
1198     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDI)
1199                                  .addReg(PPC::X2)
1200                                  .addReg(PPC::X2)
1201                                  .addExpr(TOCDeltaLo));
1202 
1203     MCSymbol *LocalEntryLabel = OutContext.createTempSymbol();
1204     OutStreamer->EmitLabel(LocalEntryLabel);
1205     const MCSymbolRefExpr *LocalEntryLabelExp =
1206        MCSymbolRefExpr::create(LocalEntryLabel, OutContext);
1207     const MCExpr *LocalOffsetExp =
1208       MCBinaryExpr::createSub(LocalEntryLabelExp,
1209                               GlobalEntryLabelExp, OutContext);
1210 
1211     PPCTargetStreamer *TS =
1212       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1213 
1214     if (TS)
1215       TS->emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym), LocalOffsetExp);
1216   }
1217 }
1218 
1219 /// EmitFunctionBodyEnd - Print the traceback table before the .size
1220 /// directive.
1221 ///
1222 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
1223   // Only the 64-bit target requires a traceback table.  For now,
1224   // we only emit the word of zeroes that GDB requires to find
1225   // the end of the function, and zeroes for the eight-byte
1226   // mandatory fields.
1227   // FIXME: We should fill in the eight-byte mandatory fields as described in
1228   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
1229   // currently make use of these fields).
1230   if (Subtarget->isPPC64()) {
1231     OutStreamer->EmitIntValue(0, 4/*size*/);
1232     OutStreamer->EmitIntValue(0, 8/*size*/);
1233   }
1234 }
1235 
1236 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
1237   static const char *const CPUDirectives[] = {
1238     "",
1239     "ppc",
1240     "ppc440",
1241     "ppc601",
1242     "ppc602",
1243     "ppc603",
1244     "ppc7400",
1245     "ppc750",
1246     "ppc970",
1247     "ppcA2",
1248     "ppce500mc",
1249     "ppce5500",
1250     "power3",
1251     "power4",
1252     "power5",
1253     "power5x",
1254     "power6",
1255     "power6x",
1256     "power7",
1257     "ppc64",
1258     "ppc64le"
1259   };
1260 
1261   // Get the numerically largest directive.
1262   // FIXME: How should we merge darwin directives?
1263   unsigned Directive = PPC::DIR_NONE;
1264   for (const Function &F : M) {
1265     const PPCSubtarget &STI = TM.getSubtarget<PPCSubtarget>(F);
1266     unsigned FDir = STI.getDarwinDirective();
1267     Directive = Directive > FDir ? FDir : STI.getDarwinDirective();
1268     if (STI.hasMFOCRF() && Directive < PPC::DIR_970)
1269       Directive = PPC::DIR_970;
1270     if (STI.hasAltivec() && Directive < PPC::DIR_7400)
1271       Directive = PPC::DIR_7400;
1272     if (STI.isPPC64() && Directive < PPC::DIR_64)
1273       Directive = PPC::DIR_64;
1274   }
1275 
1276   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
1277 
1278   assert(Directive < array_lengthof(CPUDirectives) &&
1279          "CPUDirectives[] might not be up-to-date!");
1280   PPCTargetStreamer &TStreamer =
1281       *static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1282   TStreamer.emitMachine(CPUDirectives[Directive]);
1283 
1284   // Prime text sections so they are adjacent.  This reduces the likelihood a
1285   // large data or debug section causes a branch to exceed 16M limit.
1286   const TargetLoweringObjectFileMachO &TLOFMacho =
1287       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1288   OutStreamer->SwitchSection(TLOFMacho.getTextCoalSection());
1289   if (TM.getRelocationModel() == Reloc::PIC_) {
1290     OutStreamer->SwitchSection(
1291            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
1292                                       MachO::S_SYMBOL_STUBS |
1293                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1294                                       32, SectionKind::getText()));
1295   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
1296     OutStreamer->SwitchSection(
1297            OutContext.getMachOSection("__TEXT","__symbol_stub1",
1298                                       MachO::S_SYMBOL_STUBS |
1299                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1300                                       16, SectionKind::getText()));
1301   }
1302   OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
1303 }
1304 
1305 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
1306   // Remove $stub suffix, add $lazy_ptr.
1307   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
1308   return Ctx.getOrCreateSymbol(NoStub + "$lazy_ptr");
1309 }
1310 
1311 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
1312   // Add $tmp suffix to $stub, yielding $stub$tmp.
1313   return Ctx.getOrCreateSymbol(Sym->getName() + "$tmp");
1314 }
1315 
1316 void PPCDarwinAsmPrinter::
1317 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
1318   bool isPPC64 = getDataLayout().getPointerSizeInBits() == 64;
1319 
1320   // Construct a local MCSubtargetInfo and shadow EmitToStreamer here.
1321   // This is because the MachineFunction won't exist (but have not yet been
1322   // freed) and since we're at the global level we can use the default
1323   // constructed subtarget.
1324   std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
1325       TM.getTargetTriple().str(), TM.getTargetCPU(),
1326       TM.getTargetFeatureString()));
1327   auto EmitToStreamer = [&STI] (MCStreamer &S, const MCInst &Inst) {
1328     S.EmitInstruction(Inst, *STI);
1329   };
1330 
1331   const TargetLoweringObjectFileMachO &TLOFMacho =
1332       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1333 
1334   // .lazy_symbol_pointer
1335   MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
1336 
1337   // Output stubs for dynamically-linked functions
1338   if (TM.getRelocationModel() == Reloc::PIC_) {
1339     MCSection *StubSection = OutContext.getMachOSection(
1340         "__TEXT", "__picsymbolstub1",
1341         MachO::S_SYMBOL_STUBS | MachO::S_ATTR_PURE_INSTRUCTIONS, 32,
1342         SectionKind::getText());
1343     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1344       OutStreamer->SwitchSection(StubSection);
1345       EmitAlignment(4);
1346 
1347       MCSymbol *Stub = Stubs[i].first;
1348       MCSymbol *RawSym = Stubs[i].second.getPointer();
1349       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1350       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
1351 
1352       OutStreamer->EmitLabel(Stub);
1353       OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1354 
1355       const MCExpr *Anon = MCSymbolRefExpr::create(AnonSymbol, OutContext);
1356       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::create(LazyPtr, OutContext);
1357       const MCExpr *Sub =
1358         MCBinaryExpr::createSub(LazyPtrExpr, Anon, OutContext);
1359 
1360       // mflr r0
1361       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
1362       // bcl 20, 31, AnonSymbol
1363       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCLalways).addExpr(Anon));
1364       OutStreamer->EmitLabel(AnonSymbol);
1365       // mflr r11
1366       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
1367       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
1368       const MCExpr *SubHa16 = PPCMCExpr::createHa(Sub, true, OutContext);
1369       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
1370         .addReg(PPC::R11)
1371         .addReg(PPC::R11)
1372         .addExpr(SubHa16));
1373       // mtlr r0
1374       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
1375 
1376       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
1377       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
1378       const MCExpr *SubLo16 = PPCMCExpr::createLo(Sub, true, OutContext);
1379       EmitToStreamer(*OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1380         .addReg(PPC::R12)
1381         .addExpr(SubLo16).addExpr(SubLo16)
1382         .addReg(PPC::R11));
1383       // mtctr r12
1384       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1385       // bctr
1386       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTR));
1387 
1388       OutStreamer->SwitchSection(LSPSection);
1389       OutStreamer->EmitLabel(LazyPtr);
1390       OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1391 
1392       MCSymbol *DyldStubBindingHelper =
1393         OutContext.getOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1394       if (isPPC64) {
1395         // .quad dyld_stub_binding_helper
1396         OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 8);
1397       } else {
1398         // .long dyld_stub_binding_helper
1399         OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 4);
1400       }
1401     }
1402     OutStreamer->AddBlankLine();
1403     return;
1404   }
1405 
1406   MCSection *StubSection = OutContext.getMachOSection(
1407       "__TEXT", "__symbol_stub1",
1408       MachO::S_SYMBOL_STUBS | MachO::S_ATTR_PURE_INSTRUCTIONS, 16,
1409       SectionKind::getText());
1410   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1411     MCSymbol *Stub = Stubs[i].first;
1412     MCSymbol *RawSym = Stubs[i].second.getPointer();
1413     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1414     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::create(LazyPtr, OutContext);
1415 
1416     OutStreamer->SwitchSection(StubSection);
1417     EmitAlignment(4);
1418     OutStreamer->EmitLabel(Stub);
1419     OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1420 
1421     // lis r11, ha16(LazyPtr)
1422     const MCExpr *LazyPtrHa16 =
1423       PPCMCExpr::createHa(LazyPtrExpr, true, OutContext);
1424     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LIS)
1425       .addReg(PPC::R11)
1426       .addExpr(LazyPtrHa16));
1427 
1428     // ldu r12, lo16(LazyPtr)(r11)
1429     // lwzu r12, lo16(LazyPtr)(r11)
1430     const MCExpr *LazyPtrLo16 =
1431       PPCMCExpr::createLo(LazyPtrExpr, true, OutContext);
1432     EmitToStreamer(*OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1433       .addReg(PPC::R12)
1434       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
1435       .addReg(PPC::R11));
1436 
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 
1457   OutStreamer->AddBlankLine();
1458 }
1459 
1460 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1461   bool isPPC64 = getDataLayout().getPointerSizeInBits() == 64;
1462 
1463   // Darwin/PPC always uses mach-o.
1464   const TargetLoweringObjectFileMachO &TLOFMacho =
1465       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1466   MachineModuleInfoMachO &MMIMacho =
1467       MMI->getObjFileInfo<MachineModuleInfoMachO>();
1468 
1469   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1470   if (!Stubs.empty())
1471     EmitFunctionStubs(Stubs);
1472 
1473   if (MAI->doesSupportExceptionHandling() && MMI) {
1474     // Add the (possibly multiple) personalities to the set of global values.
1475     // Only referenced functions get into the Personalities list.
1476     for (const Function *Personality : MMI->getPersonalities()) {
1477       if (Personality) {
1478         MCSymbol *NLPSym =
1479             getSymbolWithGlobalValueBase(Personality, "$non_lazy_ptr");
1480         MachineModuleInfoImpl::StubValueTy &StubSym =
1481             MMIMacho.getGVStubEntry(NLPSym);
1482         StubSym =
1483             MachineModuleInfoImpl::StubValueTy(getSymbol(Personality), true);
1484       }
1485     }
1486   }
1487 
1488   // Output stubs for dynamically-linked functions.
1489   Stubs = MMIMacho.GetGVStubList();
1490 
1491   // Output macho stubs for external and common global variables.
1492   if (!Stubs.empty()) {
1493     // Switch with ".non_lazy_symbol_pointer" directive.
1494     OutStreamer->SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1495     EmitAlignment(isPPC64 ? 3 : 2);
1496 
1497     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1498       // L_foo$stub:
1499       OutStreamer->EmitLabel(Stubs[i].first);
1500       //   .indirect_symbol _foo
1501       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1502       OutStreamer->EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1503 
1504       if (MCSym.getInt())
1505         // External to current translation unit.
1506         OutStreamer->EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1507       else
1508         // Internal to current translation unit.
1509         //
1510         // When we place the LSDA into the TEXT section, the type info pointers
1511         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1512         // However, sometimes the types are local to the file. So we need to
1513         // fill in the value for the NLP in those cases.
1514         OutStreamer->EmitValue(MCSymbolRefExpr::create(MCSym.getPointer(),
1515                                                        OutContext),
1516                               isPPC64 ? 8 : 4/*size*/);
1517     }
1518 
1519     Stubs.clear();
1520     OutStreamer->AddBlankLine();
1521   }
1522 
1523   Stubs = MMIMacho.GetHiddenGVStubList();
1524   if (!Stubs.empty()) {
1525     OutStreamer->SwitchSection(getObjFileLowering().getDataSection());
1526     EmitAlignment(isPPC64 ? 3 : 2);
1527 
1528     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1529       // L_foo$stub:
1530       OutStreamer->EmitLabel(Stubs[i].first);
1531       //   .long _foo
1532       OutStreamer->EmitValue(MCSymbolRefExpr::
1533                              create(Stubs[i].second.getPointer(),
1534                                     OutContext),
1535                              isPPC64 ? 8 : 4/*size*/);
1536     }
1537 
1538     Stubs.clear();
1539     OutStreamer->AddBlankLine();
1540   }
1541 
1542   // Funny Darwin hack: This flag tells the linker that no global symbols
1543   // contain code that falls through to other global symbols (e.g. the obvious
1544   // implementation of multiple entry points).  If this doesn't occur, the
1545   // linker can safely perform dead code stripping.  Since LLVM never generates
1546   // code that does this, it is always safe to set.
1547   OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1548 
1549   return AsmPrinter::doFinalization(M);
1550 }
1551 
1552 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1553 /// for a MachineFunction to the given output stream, in a format that the
1554 /// Darwin assembler can deal with.
1555 ///
1556 static AsmPrinter *
1557 createPPCAsmPrinterPass(TargetMachine &tm,
1558                         std::unique_ptr<MCStreamer> &&Streamer) {
1559   if (tm.getTargetTriple().isMacOSX())
1560     return new PPCDarwinAsmPrinter(tm, std::move(Streamer));
1561   return new PPCLinuxAsmPrinter(tm, std::move(Streamer));
1562 }
1563 
1564 // Force static initialization.
1565 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1566   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1567   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1568   TargetRegistry::RegisterAsmPrinter(ThePPC64LETarget, createPPCAsmPrinterPass);
1569 }
1570