lib/Target/PowerPC/PPCAsmPrinter.cpp

   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 IsExternal = false;
 673     bool IsNonLocalFunction = false;
 674     bool IsCommon = false;
 675     bool IsAvailExt = false;
 676
 677     if (MO.isGlobal()) {
 678       const GlobalValue *GV = MO.getGlobal();
 679       MOSymbol = getSymbol(GV);
 680       IsExternal = GV->isDeclaration();
 681       IsCommon = GV->hasCommonLinkage();
 682       IsNonLocalFunction = GV->getType()->getElementType()->isFunctionTy() &&
 683         !GV->isStrongDefinitionForLinker();
 684       IsAvailExt = GV->hasAvailableExternallyLinkage();
 685     } else if (MO.isCPI())
 686       MOSymbol = GetCPISymbol(MO.getIndex());
 687     else if (MO.isJTI())
 688       MOSymbol = GetJTISymbol(MO.getIndex());
 689     else if (MO.isBlockAddress())
 690       MOSymbol = GetBlockAddressSymbol(MO.getBlockAddress());
 691
 692     if (IsExternal || IsNonLocalFunction || IsCommon || IsAvailExt ||
 693         MO.isJTI() || MO.isBlockAddress() ||
 694         TM.getCodeModel() == CodeModel::Large)
 695       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 696
 697     const MCExpr *Exp =
 698       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_HA,
 699                               OutContext);
 700     TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
 701     EmitToStreamer(*OutStreamer, TmpInst);
 702     return;
 703   }
 704   case PPC::LDtocL: {
 705     // Transform %Xd = LDtocL <ga:@sym>, %Xs
 706     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
 707
 708     // Change the opcode to LD.  If the global address is external, has
 709     // common linkage, or is a jump table address, then reference the
 710     // associated TOC entry.  Otherwise reference the symbol directly.
 711     TmpInst.setOpcode(PPC::LD);
 712     const MachineOperand &MO = MI->getOperand(1);
 713     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() ||
 714             MO.isBlockAddress()) &&
 715            "Invalid operand for LDtocL!");
 716     MCSymbol *MOSymbol = nullptr;
 717
 718     if (MO.isJTI())
 719       MOSymbol = lookUpOrCreateTOCEntry(GetJTISymbol(MO.getIndex()));
 720     else if (MO.isBlockAddress()) {
 721       MOSymbol = GetBlockAddressSymbol(MO.getBlockAddress());
 722       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 723     }
 724     else if (MO.isCPI()) {
 725       MOSymbol = GetCPISymbol(MO.getIndex());
 726       if (TM.getCodeModel() == CodeModel::Large)
 727         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 728     }
 729     else if (MO.isGlobal()) {
 730       const GlobalValue *GValue = MO.getGlobal();
 731       MOSymbol = getSymbol(GValue);
 732       if (GValue->getType()->getElementType()->isFunctionTy() ||
 733           GValue->isDeclaration() || GValue->hasCommonLinkage() ||
 734           GValue->hasAvailableExternallyLinkage() ||
 735           TM.getCodeModel() == CodeModel::Large)
 736         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 737     }
 738
 739     const MCExpr *Exp =
 740       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
 741                               OutContext);
 742     TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
 743     EmitToStreamer(*OutStreamer, TmpInst);
 744     return;
 745   }
 746   case PPC::ADDItocL: {
 747     // Transform %Xd = ADDItocL %Xs, <ga:@sym>
 748     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
 749
 750     // Change the opcode to ADDI8.  If the global address is external, then
 751     // generate a TOC entry and reference that.  Otherwise reference the
 752     // symbol directly.
 753     TmpInst.setOpcode(PPC::ADDI8);
 754     const MachineOperand &MO = MI->getOperand(2);
 755     assert((MO.isGlobal() || MO.isCPI()) && "Invalid operand for ADDItocL");
 756     MCSymbol *MOSymbol = nullptr;
 757     bool IsExternal = false;
 758     bool IsNonLocalFunction = false;
 759
 760     if (MO.isGlobal()) {
 761       const GlobalValue *GV = MO.getGlobal();
 762       MOSymbol = getSymbol(GV);
 763       IsExternal = GV->isDeclaration();
 764       IsNonLocalFunction = GV->getType()->getElementType()->isFunctionTy() &&
 765         !GV->isStrongDefinitionForLinker();
 766     } else if (MO.isCPI())
 767       MOSymbol = GetCPISymbol(MO.getIndex());
 768
 769     if (IsNonLocalFunction || IsExternal ||
 770         TM.getCodeModel() == CodeModel::Large)
 771       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 772
 773     const MCExpr *Exp =
 774       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
 775                               OutContext);
 776     TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
 777     EmitToStreamer(*OutStreamer, TmpInst);
 778     return;
 779   }
 780   case PPC::ADDISgotTprelHA: {
 781     // Transform: %Xd = ADDISgotTprelHA %X2, <ga:@sym>
 782     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 783     assert(Subtarget->isPPC64() && "Not supported for 32-bit PowerPC");
 784     const MachineOperand &MO = MI->getOperand(2);
 785     const GlobalValue *GValue = MO.getGlobal();
 786     MCSymbol *MOSymbol = getSymbol(GValue);
 787     const MCExpr *SymGotTprel =
 788       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA,
 789                               OutContext);
 790     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
 791                                  .addReg(MI->getOperand(0).getReg())
 792                                  .addReg(MI->getOperand(1).getReg())
 793                                  .addExpr(SymGotTprel));
 794     return;
 795   }
 796   case PPC::LDgotTprelL:
 797   case PPC::LDgotTprelL32: {
 798     // Transform %Xd = LDgotTprelL <ga:@sym>, %Xs
 799     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
 800
 801     // Change the opcode to LD.
 802     TmpInst.setOpcode(isPPC64 ? PPC::LD : PPC::LWZ);
 803     const MachineOperand &MO = MI->getOperand(1);
 804     const GlobalValue *GValue = MO.getGlobal();
 805     MCSymbol *MOSymbol = getSymbol(GValue);
 806     const MCExpr *Exp =
 807       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO,
 808                               OutContext);
 809     TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
 810     EmitToStreamer(*OutStreamer, TmpInst);
 811     return;
 812   }
 813
 814   case PPC::PPC32PICGOT: {
 815     MCSymbol *GOTSymbol = OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
 816     MCSymbol *GOTRef = OutContext.createTempSymbol();
 817     MCSymbol *NextInstr = OutContext.createTempSymbol();
 818
 819     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL)
 820       // FIXME: We would like an efficient form for this, so we don't have to do
 821       // a lot of extra uniquing.
 822       .addExpr(MCSymbolRefExpr::create(NextInstr, OutContext)));
 823     const MCExpr *OffsExpr =
 824       MCBinaryExpr::createSub(MCSymbolRefExpr::create(GOTSymbol, OutContext),
 825                                 MCSymbolRefExpr::create(GOTRef, OutContext),
 826         OutContext);
 827     OutStreamer->EmitLabel(GOTRef);
 828     OutStreamer->EmitValue(OffsExpr, 4);
 829     OutStreamer->EmitLabel(NextInstr);
 830     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR)
 831                                  .addReg(MI->getOperand(0).getReg()));
 832     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LWZ)
 833                                  .addReg(MI->getOperand(1).getReg())
 834                                  .addImm(0)
 835                                  .addReg(MI->getOperand(0).getReg()));
 836     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADD4)
 837                                  .addReg(MI->getOperand(0).getReg())
 838                                  .addReg(MI->getOperand(1).getReg())
 839                                  .addReg(MI->getOperand(0).getReg()));
 840     return;
 841   }
 842   case PPC::PPC32GOT: {
 843     MCSymbol *GOTSymbol =
 844         OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
 845     const MCExpr *SymGotTlsL = MCSymbolRefExpr::create(
 846         GOTSymbol, MCSymbolRefExpr::VK_PPC_LO, OutContext);
 847     const MCExpr *SymGotTlsHA = MCSymbolRefExpr::create(
 848         GOTSymbol, MCSymbolRefExpr::VK_PPC_HA, OutContext);
 849     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LI)
 850                                  .addReg(MI->getOperand(0).getReg())
 851                                  .addExpr(SymGotTlsL));
 852     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
 853                                  .addReg(MI->getOperand(0).getReg())
 854                                  .addReg(MI->getOperand(0).getReg())
 855                                  .addExpr(SymGotTlsHA));
 856     return;
 857   }
 858   case PPC::ADDIStlsgdHA: {
 859     // Transform: %Xd = ADDIStlsgdHA %X2, <ga:@sym>
 860     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 861     assert(Subtarget->isPPC64() && "Not supported for 32-bit PowerPC");
 862     const MachineOperand &MO = MI->getOperand(2);
 863     const GlobalValue *GValue = MO.getGlobal();
 864     MCSymbol *MOSymbol = getSymbol(GValue);
 865     const MCExpr *SymGotTlsGD =
 866       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA,
 867                               OutContext);
 868     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
 869                                  .addReg(MI->getOperand(0).getReg())
 870                                  .addReg(MI->getOperand(1).getReg())
 871                                  .addExpr(SymGotTlsGD));
 872     return;
 873   }
 874   case PPC::ADDItlsgdL:
 875     // Transform: %Xd = ADDItlsgdL %Xs, <ga:@sym>
 876     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsgd@l
 877   case PPC::ADDItlsgdL32: {
 878     // Transform: %Rd = ADDItlsgdL32 %Rs, <ga:@sym>
 879     // Into:      %Rd = ADDI %Rs, sym@got@tlsgd
 880     const MachineOperand &MO = MI->getOperand(2);
 881     const GlobalValue *GValue = MO.getGlobal();
 882     MCSymbol *MOSymbol = getSymbol(GValue);
 883     const MCExpr *SymGotTlsGD = MCSymbolRefExpr::create(
 884         MOSymbol, Subtarget->isPPC64() ? MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO
 885                                        : MCSymbolRefExpr::VK_PPC_GOT_TLSGD,
 886         OutContext);
 887     EmitToStreamer(*OutStreamer,
 888                    MCInstBuilder(Subtarget->isPPC64() ? PPC::ADDI8 : PPC::ADDI)
 889                    .addReg(MI->getOperand(0).getReg())
 890                    .addReg(MI->getOperand(1).getReg())
 891                    .addExpr(SymGotTlsGD));
 892     return;
 893   }
 894   case PPC::GETtlsADDR:
 895     // Transform: %X3 = GETtlsADDR %X3, <ga:@sym>
 896     // Into: BL8_NOP_TLS __tls_get_addr(sym at tlsgd)
 897   case PPC::GETtlsADDR32: {
 898     // Transform: %R3 = GETtlsADDR32 %R3, <ga:@sym>
 899     // Into: BL_TLS __tls_get_addr(sym at tlsgd)@PLT
 900     EmitTlsCall(MI, MCSymbolRefExpr::VK_PPC_TLSGD);
 901     return;
 902   }
 903   case PPC::ADDIStlsldHA: {
 904     // Transform: %Xd = ADDIStlsldHA %X2, <ga:@sym>
 905     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsld@ha
 906     assert(Subtarget->isPPC64() && "Not supported for 32-bit PowerPC");
 907     const MachineOperand &MO = MI->getOperand(2);
 908     const GlobalValue *GValue = MO.getGlobal();
 909     MCSymbol *MOSymbol = getSymbol(GValue);
 910     const MCExpr *SymGotTlsLD =
 911       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA,
 912                               OutContext);
 913     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
 914                                  .addReg(MI->getOperand(0).getReg())
 915                                  .addReg(MI->getOperand(1).getReg())
 916                                  .addExpr(SymGotTlsLD));
 917     return;
 918   }
 919   case PPC::ADDItlsldL:
 920     // Transform: %Xd = ADDItlsldL %Xs, <ga:@sym>
 921     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsld@l
 922   case PPC::ADDItlsldL32: {
 923     // Transform: %Rd = ADDItlsldL32 %Rs, <ga:@sym>
 924     // Into:      %Rd = ADDI %Rs, sym@got@tlsld
 925     const MachineOperand &MO = MI->getOperand(2);
 926     const GlobalValue *GValue = MO.getGlobal();
 927     MCSymbol *MOSymbol = getSymbol(GValue);
 928     const MCExpr *SymGotTlsLD = MCSymbolRefExpr::create(
 929         MOSymbol, Subtarget->isPPC64() ? MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO
 930                                        : MCSymbolRefExpr::VK_PPC_GOT_TLSLD,
 931         OutContext);
 932     EmitToStreamer(*OutStreamer,
 933                    MCInstBuilder(Subtarget->isPPC64() ? PPC::ADDI8 : PPC::ADDI)
 934                        .addReg(MI->getOperand(0).getReg())
 935                        .addReg(MI->getOperand(1).getReg())
 936                        .addExpr(SymGotTlsLD));
 937     return;
 938   }
 939   case PPC::GETtlsldADDR:
 940     // Transform: %X3 = GETtlsldADDR %X3, <ga:@sym>
 941     // Into: BL8_NOP_TLS __tls_get_addr(sym at tlsld)
 942   case PPC::GETtlsldADDR32: {
 943     // Transform: %R3 = GETtlsldADDR32 %R3, <ga:@sym>
 944     // Into: BL_TLS __tls_get_addr(sym at tlsld)@PLT
 945     EmitTlsCall(MI, MCSymbolRefExpr::VK_PPC_TLSLD);
 946     return;
 947   }
 948   case PPC::ADDISdtprelHA:
 949     // Transform: %Xd = ADDISdtprelHA %Xs, <ga:@sym>
 950     // Into:      %Xd = ADDIS8 %Xs, sym@dtprel@ha
 951   case PPC::ADDISdtprelHA32: {
 952     // Transform: %Rd = ADDISdtprelHA32 %Rs, <ga:@sym>
 953     // Into:      %Rd = ADDIS %Rs, sym@dtprel@ha
 954     const MachineOperand &MO = MI->getOperand(2);
 955     const GlobalValue *GValue = MO.getGlobal();
 956     MCSymbol *MOSymbol = getSymbol(GValue);
 957     const MCExpr *SymDtprel =
 958       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_HA,
 959                               OutContext);
 960     EmitToStreamer(
 961         *OutStreamer,
 962         MCInstBuilder(Subtarget->isPPC64() ? PPC::ADDIS8 : PPC::ADDIS)
 963             .addReg(MI->getOperand(0).getReg())
 964             .addReg(MI->getOperand(1).getReg())
 965             .addExpr(SymDtprel));
 966     return;
 967   }
 968   case PPC::ADDIdtprelL:
 969     // Transform: %Xd = ADDIdtprelL %Xs, <ga:@sym>
 970     // Into:      %Xd = ADDI8 %Xs, sym@dtprel@l
 971   case PPC::ADDIdtprelL32: {
 972     // Transform: %Rd = ADDIdtprelL32 %Rs, <ga:@sym>
 973     // Into:      %Rd = ADDI %Rs, sym@dtprel@l
 974     const MachineOperand &MO = MI->getOperand(2);
 975     const GlobalValue *GValue = MO.getGlobal();
 976     MCSymbol *MOSymbol = getSymbol(GValue);
 977     const MCExpr *SymDtprel =
 978       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_LO,
 979                               OutContext);
 980     EmitToStreamer(*OutStreamer,
 981                    MCInstBuilder(Subtarget->isPPC64() ? PPC::ADDI8 : PPC::ADDI)
 982                        .addReg(MI->getOperand(0).getReg())
 983                        .addReg(MI->getOperand(1).getReg())
 984                        .addExpr(SymDtprel));
 985     return;
 986   }
 987   case PPC::MFOCRF:
 988   case PPC::MFOCRF8:
 989     if (!Subtarget->hasMFOCRF()) {
 990       // Transform: %R3 = MFOCRF %CR7
 991       // Into:      %R3 = MFCR   ;; cr7
 992       unsigned NewOpcode =
 993         MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
 994       OutStreamer->AddComment(PPCInstPrinter::
 995                               getRegisterName(MI->getOperand(1).getReg()));
 996       EmitToStreamer(*OutStreamer, MCInstBuilder(NewOpcode)
 997                                   .addReg(MI->getOperand(0).getReg()));
 998       return;
 999     }
1000     break;
1001   case PPC::MTOCRF:
1002   case PPC::MTOCRF8:
1003     if (!Subtarget->hasMFOCRF()) {
1004       // Transform: %CR7 = MTOCRF %R3
1005       // Into:      MTCRF mask, %R3 ;; cr7
1006       unsigned NewOpcode =
1007         MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
1008       unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
1009                               ->getEncodingValue(MI->getOperand(0).getReg());
1010       OutStreamer->AddComment(PPCInstPrinter::
1011                               getRegisterName(MI->getOperand(0).getReg()));
1012       EmitToStreamer(*OutStreamer, MCInstBuilder(NewOpcode)
1013                                      .addImm(Mask)
1014                                      .addReg(MI->getOperand(1).getReg()));
1015       return;
1016     }
1017     break;
1018   case PPC::LD:
1019   case PPC::STD:
1020   case PPC::LWA_32:
1021   case PPC::LWA: {
1022     // Verify alignment is legal, so we don't create relocations
1023     // that can't be supported.
1024     // FIXME:  This test is currently disabled for Darwin.  The test
1025     // suite shows a handful of test cases that fail this check for
1026     // Darwin.  Those need to be investigated before this sanity test
1027     // can be enabled for those subtargets.
1028     if (!Subtarget->isDarwin()) {
1029       unsigned OpNum = (MI->getOpcode() == PPC::STD) ? 2 : 1;
1030       const MachineOperand &MO = MI->getOperand(OpNum);
1031       if (MO.isGlobal() && MO.getGlobal()->getAlignment() < 4)
1032         llvm_unreachable("Global must be word-aligned for LD, STD, LWA!");
1033     }
1034     // Now process the instruction normally.
1035     break;
1036   }
1037   }
1038
1039   LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, isDarwin);
1040   EmitToStreamer(*OutStreamer, TmpInst);
1041 }
1042
1043 void PPCLinuxAsmPrinter::EmitStartOfAsmFile(Module &M) {
1044   if (static_cast<const PPCTargetMachine &>(TM).isELFv2ABI()) {
1045     PPCTargetStreamer *TS =
1046       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1047
1048     if (TS)
1049       TS->emitAbiVersion(2);
1050   }
1051
1052   if (static_cast<const PPCTargetMachine &>(TM).isPPC64() ||
1053       TM.getRelocationModel() != Reloc::PIC_)
1054     return AsmPrinter::EmitStartOfAsmFile(M);
1055
1056   if (M.getPICLevel() == PICLevel::Small)
1057     return AsmPrinter::EmitStartOfAsmFile(M);
1058
1059   OutStreamer->SwitchSection(OutContext.getELFSection(
1060       ".got2", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC));
1061
1062   MCSymbol *TOCSym = OutContext.getOrCreateSymbol(Twine(".LTOC"));
1063   MCSymbol *CurrentPos = OutContext.createTempSymbol();
1064
1065   OutStreamer->EmitLabel(CurrentPos);
1066
1067   // The GOT pointer points to the middle of the GOT, in order to reference the
1068   // entire 64kB range.  0x8000 is the midpoint.
1069   const MCExpr *tocExpr =
1070     MCBinaryExpr::createAdd(MCSymbolRefExpr::create(CurrentPos, OutContext),
1071                             MCConstantExpr::create(0x8000, OutContext),
1072                             OutContext);
1073
1074   OutStreamer->EmitAssignment(TOCSym, tocExpr);
1075
1076   OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
1077 }
1078
1079 void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
1080   // linux/ppc32 - Normal entry label.
1081   if (!Subtarget->isPPC64() &&
1082       (TM.getRelocationModel() != Reloc::PIC_ ||
1083        MF->getFunction()->getParent()->getPICLevel() == PICLevel::Small))
1084     return AsmPrinter::EmitFunctionEntryLabel();
1085
1086   if (!Subtarget->isPPC64()) {
1087     const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
1088     if (PPCFI->usesPICBase()) {
1089       MCSymbol *RelocSymbol = PPCFI->getPICOffsetSymbol();
1090       MCSymbol *PICBase = MF->getPICBaseSymbol();
1091       OutStreamer->EmitLabel(RelocSymbol);
1092
1093       const MCExpr *OffsExpr =
1094         MCBinaryExpr::createSub(
1095           MCSymbolRefExpr::create(OutContext.getOrCreateSymbol(Twine(".LTOC")),
1096                                                                OutContext),
1097                                   MCSymbolRefExpr::create(PICBase, OutContext),
1098           OutContext);
1099       OutStreamer->EmitValue(OffsExpr, 4);
1100       OutStreamer->EmitLabel(CurrentFnSym);
1101       return;
1102     } else
1103       return AsmPrinter::EmitFunctionEntryLabel();
1104   }
1105
1106   // ELFv2 ABI - Normal entry label.
1107   if (Subtarget->isELFv2ABI())
1108     return AsmPrinter::EmitFunctionEntryLabel();
1109
1110   // Emit an official procedure descriptor.
1111   MCSectionSubPair Current = OutStreamer->getCurrentSection();
1112   MCSectionELF *Section = OutStreamer->getContext().getELFSection(
1113       ".opd", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1114   OutStreamer->SwitchSection(Section);
1115   OutStreamer->EmitLabel(CurrentFnSym);
1116   OutStreamer->EmitValueToAlignment(8);
1117   MCSymbol *Symbol1 = CurrentFnSymForSize;
1118   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
1119   // entry point.
1120   OutStreamer->EmitValue(MCSymbolRefExpr::create(Symbol1, OutContext),
1121                          8 /*size*/);
1122   MCSymbol *Symbol2 = OutContext.getOrCreateSymbol(StringRef(".TOC."));
1123   // Generates a R_PPC64_TOC relocation for TOC base insertion.
1124   OutStreamer->EmitValue(
1125     MCSymbolRefExpr::create(Symbol2, MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
1126     8/*size*/);
1127   // Emit a null environment pointer.
1128   OutStreamer->EmitIntValue(0, 8 /* size */);
1129   OutStreamer->SwitchSection(Current.first, Current.second);
1130 }
1131
1132 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
1133   const DataLayout &DL = getDataLayout();
1134
1135   bool isPPC64 = DL.getPointerSizeInBits() == 64;
1136
1137   PPCTargetStreamer &TS =
1138       static_cast<PPCTargetStreamer &>(*OutStreamer->getTargetStreamer());
1139
1140   if (!TOC.empty()) {
1141     MCSectionELF *Section;
1142
1143     if (isPPC64)
1144       Section = OutStreamer->getContext().getELFSection(
1145           ".toc", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1146         else
1147           Section = OutStreamer->getContext().getELFSection(
1148               ".got2", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1149     OutStreamer->SwitchSection(Section);
1150
1151     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
1152          E = TOC.end(); I != E; ++I) {
1153       OutStreamer->EmitLabel(I->second);
1154       MCSymbol *S = I->first;
1155       if (isPPC64)
1156         TS.emitTCEntry(*S);
1157       else
1158         OutStreamer->EmitSymbolValue(S, 4);
1159     }
1160   }
1161
1162   return AsmPrinter::doFinalization(M);
1163 }
1164
1165 /// EmitFunctionBodyStart - Emit a global entry point prefix for ELFv2.
1166 void PPCLinuxAsmPrinter::EmitFunctionBodyStart() {
1167   // In the ELFv2 ABI, in functions that use the TOC register, we need to
1168   // provide two entry points.  The ABI guarantees that when calling the
1169   // local entry point, r2 is set up by the caller to contain the TOC base
1170   // for this function, and when calling the global entry point, r12 is set
1171   // up by the caller to hold the address of the global entry point.  We
1172   // thus emit a prefix sequence along the following lines:
1173   //
1174   // func:
1175   //         # global entry point
1176   //         addis r2,r12,(.TOC.-func)@ha
1177   //         addi  r2,r2,(.TOC.-func)@l
1178   //         .localentry func, .-func
1179   //         # local entry point, followed by function body
1180   //
1181   // This ensures we have r2 set up correctly while executing the function
1182   // body, no matter which entry point is called.
1183   if (Subtarget->isELFv2ABI()
1184       // Only do all that if the function uses r2 in the first place.
1185       && !MF->getRegInfo().use_empty(PPC::X2)) {
1186
1187     MCSymbol *GlobalEntryLabel = OutContext.createTempSymbol();
1188     OutStreamer->EmitLabel(GlobalEntryLabel);
1189     const MCSymbolRefExpr *GlobalEntryLabelExp =
1190       MCSymbolRefExpr::create(GlobalEntryLabel, OutContext);
1191
1192     MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(StringRef(".TOC."));
1193     const MCExpr *TOCDeltaExpr =
1194       MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
1195                               GlobalEntryLabelExp, OutContext);
1196
1197     const MCExpr *TOCDeltaHi =
1198       PPCMCExpr::createHa(TOCDeltaExpr, false, OutContext);
1199     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
1200                                  .addReg(PPC::X2)
1201                                  .addReg(PPC::X12)
1202                                  .addExpr(TOCDeltaHi));
1203
1204     const MCExpr *TOCDeltaLo =
1205       PPCMCExpr::createLo(TOCDeltaExpr, false, OutContext);
1206     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDI)
1207                                  .addReg(PPC::X2)
1208                                  .addReg(PPC::X2)
1209                                  .addExpr(TOCDeltaLo));
1210
1211     MCSymbol *LocalEntryLabel = OutContext.createTempSymbol();
1212     OutStreamer->EmitLabel(LocalEntryLabel);
1213     const MCSymbolRefExpr *LocalEntryLabelExp =
1214        MCSymbolRefExpr::create(LocalEntryLabel, OutContext);
1215     const MCExpr *LocalOffsetExp =
1216       MCBinaryExpr::createSub(LocalEntryLabelExp,
1217                               GlobalEntryLabelExp, OutContext);
1218
1219     PPCTargetStreamer *TS =
1220       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1221
1222     if (TS)
1223       TS->emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym), LocalOffsetExp);
1224   }
1225 }
1226
1227 /// EmitFunctionBodyEnd - Print the traceback table before the .size
1228 /// directive.
1229 ///
1230 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
1231   // Only the 64-bit target requires a traceback table.  For now,
1232   // we only emit the word of zeroes that GDB requires to find
1233   // the end of the function, and zeroes for the eight-byte
1234   // mandatory fields.
1235   // FIXME: We should fill in the eight-byte mandatory fields as described in
1236   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
1237   // currently make use of these fields).
1238   if (Subtarget->isPPC64()) {
1239     OutStreamer->EmitIntValue(0, 4/*size*/);
1240     OutStreamer->EmitIntValue(0, 8/*size*/);
1241   }
1242 }
1243
1244 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
1245   static const char *const CPUDirectives[] = {
1246     "",
1247     "ppc",
1248     "ppc440",
1249     "ppc601",
1250     "ppc602",
1251     "ppc603",
1252     "ppc7400",
1253     "ppc750",
1254     "ppc970",
1255     "ppcA2",
1256     "ppce500mc",
1257     "ppce5500",
1258     "power3",
1259     "power4",
1260     "power5",
1261     "power5x",
1262     "power6",
1263     "power6x",
1264     "power7",
1265     "ppc64",
1266     "ppc64le"
1267   };
1268
1269   // Get the numerically largest directive.
1270   // FIXME: How should we merge darwin directives?
1271   unsigned Directive = PPC::DIR_NONE;
1272   for (const Function &F : M) {
1273     const PPCSubtarget &STI = TM.getSubtarget<PPCSubtarget>(F);
1274     unsigned FDir = STI.getDarwinDirective();
1275     Directive = Directive > FDir ? FDir : STI.getDarwinDirective();
1276     if (STI.hasMFOCRF() && Directive < PPC::DIR_970)
1277       Directive = PPC::DIR_970;
1278     if (STI.hasAltivec() && Directive < PPC::DIR_7400)
1279       Directive = PPC::DIR_7400;
1280     if (STI.isPPC64() && Directive < PPC::DIR_64)
1281       Directive = PPC::DIR_64;
1282   }
1283
1284   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
1285
1286   assert(Directive < array_lengthof(CPUDirectives) &&
1287          "CPUDirectives[] might not be up-to-date!");
1288   PPCTargetStreamer &TStreamer =
1289       *static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1290   TStreamer.emitMachine(CPUDirectives[Directive]);
1291
1292   // Prime text sections so they are adjacent.  This reduces the likelihood a
1293   // large data or debug section causes a branch to exceed 16M limit.
1294   const TargetLoweringObjectFileMachO &TLOFMacho =
1295       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1296   OutStreamer->SwitchSection(TLOFMacho.getTextCoalSection());
1297   if (TM.getRelocationModel() == Reloc::PIC_) {
1298     OutStreamer->SwitchSection(
1299            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
1300                                       MachO::S_SYMBOL_STUBS |
1301                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1302                                       32, SectionKind::getText()));
1303   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
1304     OutStreamer->SwitchSection(
1305            OutContext.getMachOSection("__TEXT","__symbol_stub1",
1306                                       MachO::S_SYMBOL_STUBS |
1307                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1308                                       16, SectionKind::getText()));
1309   }
1310   OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
1311 }
1312
1313 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
1314   // Remove $stub suffix, add $lazy_ptr.
1315   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
1316   return Ctx.getOrCreateSymbol(NoStub + "$lazy_ptr");
1317 }
1318
1319 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
1320   // Add $tmp suffix to $stub, yielding $stub$tmp.
1321   return Ctx.getOrCreateSymbol(Sym->getName() + "$tmp");
1322 }
1323
1324 void PPCDarwinAsmPrinter::
1325 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
1326   bool isPPC64 = getDataLayout().getPointerSizeInBits() == 64;
1327
1328   // Construct a local MCSubtargetInfo and shadow EmitToStreamer here.
1329   // This is because the MachineFunction won't exist (but have not yet been
1330   // freed) and since we're at the global level we can use the default
1331   // constructed subtarget.
1332   std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
1333       TM.getTargetTriple().str(), TM.getTargetCPU(),
1334       TM.getTargetFeatureString()));
1335   auto EmitToStreamer = [&STI] (MCStreamer &S, const MCInst &Inst) {
1336     S.EmitInstruction(Inst, *STI);
1337   };
1338
1339   const TargetLoweringObjectFileMachO &TLOFMacho =
1340       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1341
1342   // .lazy_symbol_pointer
1343   MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
1344
1345   // Output stubs for dynamically-linked functions
1346   if (TM.getRelocationModel() == Reloc::PIC_) {
1347     MCSection *StubSection = OutContext.getMachOSection(
1348         "__TEXT", "__picsymbolstub1",
1349         MachO::S_SYMBOL_STUBS | MachO::S_ATTR_PURE_INSTRUCTIONS, 32,
1350         SectionKind::getText());
1351     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1352       OutStreamer->SwitchSection(StubSection);
1353       EmitAlignment(4);
1354
1355       MCSymbol *Stub = Stubs[i].first;
1356       MCSymbol *RawSym = Stubs[i].second.getPointer();
1357       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1358       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
1359
1360       OutStreamer->EmitLabel(Stub);
1361       OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1362
1363       const MCExpr *Anon = MCSymbolRefExpr::create(AnonSymbol, OutContext);
1364       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::create(LazyPtr, OutContext);
1365       const MCExpr *Sub =
1366         MCBinaryExpr::createSub(LazyPtrExpr, Anon, OutContext);
1367
1368       // mflr r0
1369       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
1370       // bcl 20, 31, AnonSymbol
1371       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCLalways).addExpr(Anon));
1372       OutStreamer->EmitLabel(AnonSymbol);
1373       // mflr r11
1374       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
1375       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
1376       const MCExpr *SubHa16 = PPCMCExpr::createHa(Sub, true, OutContext);
1377       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
1378         .addReg(PPC::R11)
1379         .addReg(PPC::R11)
1380         .addExpr(SubHa16));
1381       // mtlr r0
1382       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
1383
1384       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
1385       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
1386       const MCExpr *SubLo16 = PPCMCExpr::createLo(Sub, true, OutContext);
1387       EmitToStreamer(*OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1388         .addReg(PPC::R12)
1389         .addExpr(SubLo16).addExpr(SubLo16)
1390         .addReg(PPC::R11));
1391       // mtctr r12
1392       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1393       // bctr
1394       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTR));
1395
1396       OutStreamer->SwitchSection(LSPSection);
1397       OutStreamer->EmitLabel(LazyPtr);
1398       OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1399
1400       MCSymbol *DyldStubBindingHelper =
1401         OutContext.getOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1402       if (isPPC64) {
1403         // .quad dyld_stub_binding_helper
1404         OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 8);
1405       } else {
1406         // .long dyld_stub_binding_helper
1407         OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 4);
1408       }
1409     }
1410     OutStreamer->AddBlankLine();
1411     return;
1412   }
1413
1414   MCSection *StubSection = OutContext.getMachOSection(
1415       "__TEXT", "__symbol_stub1",
1416       MachO::S_SYMBOL_STUBS | MachO::S_ATTR_PURE_INSTRUCTIONS, 16,
1417       SectionKind::getText());
1418   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1419     MCSymbol *Stub = Stubs[i].first;
1420     MCSymbol *RawSym = Stubs[i].second.getPointer();
1421     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1422     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::create(LazyPtr, OutContext);
1423
1424     OutStreamer->SwitchSection(StubSection);
1425     EmitAlignment(4);
1426     OutStreamer->EmitLabel(Stub);
1427     OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1428
1429     // lis r11, ha16(LazyPtr)
1430     const MCExpr *LazyPtrHa16 =
1431       PPCMCExpr::createHa(LazyPtrExpr, true, OutContext);
1432     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LIS)
1433       .addReg(PPC::R11)
1434       .addExpr(LazyPtrHa16));
1435
1436     // ldu r12, lo16(LazyPtr)(r11)
1437     // lwzu r12, lo16(LazyPtr)(r11)
1438     const MCExpr *LazyPtrLo16 =
1439       PPCMCExpr::createLo(LazyPtrExpr, true, OutContext);
1440     EmitToStreamer(*OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1441       .addReg(PPC::R12)
1442       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
1443       .addReg(PPC::R11));
1444
1445     // mtctr r12
1446     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1447     // bctr
1448     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTR));
1449
1450     OutStreamer->SwitchSection(LSPSection);
1451     OutStreamer->EmitLabel(LazyPtr);
1452     OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1453
1454     MCSymbol *DyldStubBindingHelper =
1455       OutContext.getOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1456     if (isPPC64) {
1457       // .quad dyld_stub_binding_helper
1458       OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 8);
1459     } else {
1460       // .long dyld_stub_binding_helper
1461       OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 4);
1462     }
1463   }
1464
1465   OutStreamer->AddBlankLine();
1466 }
1467
1468 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1469   bool isPPC64 = getDataLayout().getPointerSizeInBits() == 64;
1470
1471   // Darwin/PPC always uses mach-o.
1472   const TargetLoweringObjectFileMachO &TLOFMacho =
1473       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1474   MachineModuleInfoMachO &MMIMacho =
1475       MMI->getObjFileInfo<MachineModuleInfoMachO>();
1476
1477   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1478   if (!Stubs.empty())
1479     EmitFunctionStubs(Stubs);
1480
1481   if (MAI->doesSupportExceptionHandling() && MMI) {
1482     // Add the (possibly multiple) personalities to the set of global values.
1483     // Only referenced functions get into the Personalities list.
1484     for (const Function *Personality : MMI->getPersonalities()) {
1485       if (Personality) {
1486         MCSymbol *NLPSym =
1487             getSymbolWithGlobalValueBase(Personality, "$non_lazy_ptr");
1488         MachineModuleInfoImpl::StubValueTy &StubSym =
1489             MMIMacho.getGVStubEntry(NLPSym);
1490         StubSym =
1491             MachineModuleInfoImpl::StubValueTy(getSymbol(Personality), true);
1492       }
1493     }
1494   }
1495
1496   // Output stubs for dynamically-linked functions.
1497   Stubs = MMIMacho.GetGVStubList();
1498
1499   // Output macho stubs for external and common global variables.
1500   if (!Stubs.empty()) {
1501     // Switch with ".non_lazy_symbol_pointer" directive.
1502     OutStreamer->SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1503     EmitAlignment(isPPC64 ? 3 : 2);
1504
1505     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1506       // L_foo$stub:
1507       OutStreamer->EmitLabel(Stubs[i].first);
1508       //   .indirect_symbol _foo
1509       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1510       OutStreamer->EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1511
1512       if (MCSym.getInt())
1513         // External to current translation unit.
1514         OutStreamer->EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1515       else
1516         // Internal to current translation unit.
1517         //
1518         // When we place the LSDA into the TEXT section, the type info pointers
1519         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1520         // However, sometimes the types are local to the file. So we need to
1521         // fill in the value for the NLP in those cases.
1522         OutStreamer->EmitValue(MCSymbolRefExpr::create(MCSym.getPointer(),
1523                                                        OutContext),
1524                               isPPC64 ? 8 : 4/*size*/);
1525     }
1526
1527     Stubs.clear();
1528     OutStreamer->AddBlankLine();
1529   }
1530
1531   Stubs = MMIMacho.GetHiddenGVStubList();
1532   if (!Stubs.empty()) {
1533     OutStreamer->SwitchSection(getObjFileLowering().getDataSection());
1534     EmitAlignment(isPPC64 ? 3 : 2);
1535
1536     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1537       // L_foo$stub:
1538       OutStreamer->EmitLabel(Stubs[i].first);
1539       //   .long _foo
1540       OutStreamer->EmitValue(MCSymbolRefExpr::
1541                              create(Stubs[i].second.getPointer(),
1542                                     OutContext),
1543                              isPPC64 ? 8 : 4/*size*/);
1544     }
1545
1546     Stubs.clear();
1547     OutStreamer->AddBlankLine();
1548   }
1549
1550   // Funny Darwin hack: This flag tells the linker that no global symbols
1551   // contain code that falls through to other global symbols (e.g. the obvious
1552   // implementation of multiple entry points).  If this doesn't occur, the
1553   // linker can safely perform dead code stripping.  Since LLVM never generates
1554   // code that does this, it is always safe to set.
1555   OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1556
1557   return AsmPrinter::doFinalization(M);
1558 }
1559
1560 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1561 /// for a MachineFunction to the given output stream, in a format that the
1562 /// Darwin assembler can deal with.
1563 ///
1564 static AsmPrinter *
1565 createPPCAsmPrinterPass(TargetMachine &tm,
1566                         std::unique_ptr<MCStreamer> &&Streamer) {
1567   if (tm.getTargetTriple().isMacOSX())
1568     return new PPCDarwinAsmPrinter(tm, std::move(Streamer));
1569   return new PPCLinuxAsmPrinter(tm, std::move(Streamer));
1570 }
1571
1572 // Force static initialization.
1573 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1574   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1575   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1576   TargetRegistry::RegisterAsmPrinter(ThePPC64LETarget, createPPCAsmPrinterPass);
1577 }