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