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