contrib/llvm/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     // In the Large code model, we allow arbitrary displacements between
1097     // the text section and its associated TOC section.  We place the
1098     // full 8-byte offset to the TOC in memory immediatedly preceding
1099     // the function global entry point.
1100     if (TM.getCodeModel() == CodeModel::Large
1101         && !MF->getRegInfo().use_empty(PPC::X2)) {
1102       const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
1103
1104       MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(StringRef(".TOC."));
1105       MCSymbol *GlobalEPSymbol = PPCFI->getGlobalEPSymbol();
1106       const MCExpr *TOCDeltaExpr =
1107         MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
1108                                 MCSymbolRefExpr::create(GlobalEPSymbol,
1109                                                         OutContext),
1110                                 OutContext);
1111
1112       OutStreamer->EmitLabel(PPCFI->getTOCOffsetSymbol());
1113       OutStreamer->EmitValue(TOCDeltaExpr, 8);
1114     }
1115     return AsmPrinter::EmitFunctionEntryLabel();
1116   }
1117
1118   // Emit an official procedure descriptor.
1119   MCSectionSubPair Current = OutStreamer->getCurrentSection();
1120   MCSectionELF *Section = OutStreamer->getContext().getELFSection(
1121       ".opd", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1122   OutStreamer->SwitchSection(Section);
1123   OutStreamer->EmitLabel(CurrentFnSym);
1124   OutStreamer->EmitValueToAlignment(8);
1125   MCSymbol *Symbol1 = CurrentFnSymForSize;
1126   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
1127   // entry point.
1128   OutStreamer->EmitValue(MCSymbolRefExpr::create(Symbol1, OutContext),
1129                          8 /*size*/);
1130   MCSymbol *Symbol2 = OutContext.getOrCreateSymbol(StringRef(".TOC."));
1131   // Generates a R_PPC64_TOC relocation for TOC base insertion.
1132   OutStreamer->EmitValue(
1133     MCSymbolRefExpr::create(Symbol2, MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
1134     8/*size*/);
1135   // Emit a null environment pointer.
1136   OutStreamer->EmitIntValue(0, 8 /* size */);
1137   OutStreamer->SwitchSection(Current.first, Current.second);
1138 }
1139
1140 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
1141   const DataLayout &DL = getDataLayout();
1142
1143   bool isPPC64 = DL.getPointerSizeInBits() == 64;
1144
1145   PPCTargetStreamer &TS =
1146       static_cast<PPCTargetStreamer &>(*OutStreamer->getTargetStreamer());
1147
1148   if (!TOC.empty()) {
1149     MCSectionELF *Section;
1150
1151     if (isPPC64)
1152       Section = OutStreamer->getContext().getELFSection(
1153           ".toc", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1154         else
1155           Section = OutStreamer->getContext().getELFSection(
1156               ".got2", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
1157     OutStreamer->SwitchSection(Section);
1158
1159     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
1160          E = TOC.end(); I != E; ++I) {
1161       OutStreamer->EmitLabel(I->second);
1162       MCSymbol *S = I->first;
1163       if (isPPC64)
1164         TS.emitTCEntry(*S);
1165       else
1166         OutStreamer->EmitSymbolValue(S, 4);
1167     }
1168   }
1169
1170   return AsmPrinter::doFinalization(M);
1171 }
1172
1173 /// EmitFunctionBodyStart - Emit a global entry point prefix for ELFv2.
1174 void PPCLinuxAsmPrinter::EmitFunctionBodyStart() {
1175   // In the ELFv2 ABI, in functions that use the TOC register, we need to
1176   // provide two entry points.  The ABI guarantees that when calling the
1177   // local entry point, r2 is set up by the caller to contain the TOC base
1178   // for this function, and when calling the global entry point, r12 is set
1179   // up by the caller to hold the address of the global entry point.  We
1180   // thus emit a prefix sequence along the following lines:
1181   //
1182   // func:
1183   // .Lfunc_gepNN:
1184   //         # global entry point
1185   //         addis r2,r12,(.TOC.-.Lfunc_gepNN)@ha
1186   //         addi  r2,r2,(.TOC.-.Lfunc_gepNN)@l
1187   // .Lfunc_lepNN:
1188   //         .localentry func, .Lfunc_lepNN-.Lfunc_gepNN
1189   //         # local entry point, followed by function body
1190   //
1191   // For the Large code model, we create
1192   //
1193   // .Lfunc_tocNN:
1194   //         .quad .TOC.-.Lfunc_gepNN      # done by EmitFunctionEntryLabel
1195   // func:
1196   // .Lfunc_gepNN:
1197   //         # global entry point
1198   //         ld    r2,.Lfunc_tocNN-.Lfunc_gepNN(r12)
1199   //         add   r2,r2,r12
1200   // .Lfunc_lepNN:
1201   //         .localentry func, .Lfunc_lepNN-.Lfunc_gepNN
1202   //         # local entry point, followed by function body
1203   //
1204   // This ensures we have r2 set up correctly while executing the function
1205   // body, no matter which entry point is called.
1206   if (Subtarget->isELFv2ABI()
1207       // Only do all that if the function uses r2 in the first place.
1208       && !MF->getRegInfo().use_empty(PPC::X2)) {
1209     const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
1210
1211     MCSymbol *GlobalEntryLabel = PPCFI->getGlobalEPSymbol();
1212     OutStreamer->EmitLabel(GlobalEntryLabel);
1213     const MCSymbolRefExpr *GlobalEntryLabelExp =
1214       MCSymbolRefExpr::create(GlobalEntryLabel, OutContext);
1215
1216     if (TM.getCodeModel() != CodeModel::Large) {
1217       MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(StringRef(".TOC."));
1218       const MCExpr *TOCDeltaExpr =
1219         MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
1220                                 GlobalEntryLabelExp, OutContext);
1221
1222       const MCExpr *TOCDeltaHi =
1223         PPCMCExpr::createHa(TOCDeltaExpr, false, OutContext);
1224       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
1225                                    .addReg(PPC::X2)
1226                                    .addReg(PPC::X12)
1227                                    .addExpr(TOCDeltaHi));
1228
1229       const MCExpr *TOCDeltaLo =
1230         PPCMCExpr::createLo(TOCDeltaExpr, false, OutContext);
1231       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDI)
1232                                    .addReg(PPC::X2)
1233                                    .addReg(PPC::X2)
1234                                    .addExpr(TOCDeltaLo));
1235     } else {
1236       MCSymbol *TOCOffset = PPCFI->getTOCOffsetSymbol();
1237       const MCExpr *TOCOffsetDeltaExpr =
1238         MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCOffset, OutContext),
1239                                 GlobalEntryLabelExp, OutContext);
1240
1241       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
1242                                    .addReg(PPC::X2)
1243                                    .addExpr(TOCOffsetDeltaExpr)
1244                                    .addReg(PPC::X12));
1245       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADD8)
1246                                    .addReg(PPC::X2)
1247                                    .addReg(PPC::X2)
1248                                    .addReg(PPC::X12));
1249     }
1250
1251     MCSymbol *LocalEntryLabel = PPCFI->getLocalEPSymbol();
1252     OutStreamer->EmitLabel(LocalEntryLabel);
1253     const MCSymbolRefExpr *LocalEntryLabelExp =
1254        MCSymbolRefExpr::create(LocalEntryLabel, OutContext);
1255     const MCExpr *LocalOffsetExp =
1256       MCBinaryExpr::createSub(LocalEntryLabelExp,
1257                               GlobalEntryLabelExp, OutContext);
1258
1259     PPCTargetStreamer *TS =
1260       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1261
1262     if (TS)
1263       TS->emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym), LocalOffsetExp);
1264   }
1265 }
1266
1267 /// EmitFunctionBodyEnd - Print the traceback table before the .size
1268 /// directive.
1269 ///
1270 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
1271   // Only the 64-bit target requires a traceback table.  For now,
1272   // we only emit the word of zeroes that GDB requires to find
1273   // the end of the function, and zeroes for the eight-byte
1274   // mandatory fields.
1275   // FIXME: We should fill in the eight-byte mandatory fields as described in
1276   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
1277   // currently make use of these fields).
1278   if (Subtarget->isPPC64()) {
1279     OutStreamer->EmitIntValue(0, 4/*size*/);
1280     OutStreamer->EmitIntValue(0, 8/*size*/);
1281   }
1282 }
1283
1284 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
1285   static const char *const CPUDirectives[] = {
1286     "",
1287     "ppc",
1288     "ppc440",
1289     "ppc601",
1290     "ppc602",
1291     "ppc603",
1292     "ppc7400",
1293     "ppc750",
1294     "ppc970",
1295     "ppcA2",
1296     "ppce500mc",
1297     "ppce5500",
1298     "power3",
1299     "power4",
1300     "power5",
1301     "power5x",
1302     "power6",
1303     "power6x",
1304     "power7",
1305     "ppc64",
1306     "ppc64le"
1307   };
1308
1309   // Get the numerically largest directive.
1310   // FIXME: How should we merge darwin directives?
1311   unsigned Directive = PPC::DIR_NONE;
1312   for (const Function &F : M) {
1313     const PPCSubtarget &STI = TM.getSubtarget<PPCSubtarget>(F);
1314     unsigned FDir = STI.getDarwinDirective();
1315     Directive = Directive > FDir ? FDir : STI.getDarwinDirective();
1316     if (STI.hasMFOCRF() && Directive < PPC::DIR_970)
1317       Directive = PPC::DIR_970;
1318     if (STI.hasAltivec() && Directive < PPC::DIR_7400)
1319       Directive = PPC::DIR_7400;
1320     if (STI.isPPC64() && Directive < PPC::DIR_64)
1321       Directive = PPC::DIR_64;
1322   }
1323
1324   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
1325
1326   assert(Directive < array_lengthof(CPUDirectives) &&
1327          "CPUDirectives[] might not be up-to-date!");
1328   PPCTargetStreamer &TStreamer =
1329       *static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
1330   TStreamer.emitMachine(CPUDirectives[Directive]);
1331
1332   // Prime text sections so they are adjacent.  This reduces the likelihood a
1333   // large data or debug section causes a branch to exceed 16M limit.
1334   const TargetLoweringObjectFileMachO &TLOFMacho =
1335       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1336   OutStreamer->SwitchSection(TLOFMacho.getTextCoalSection());
1337   if (TM.getRelocationModel() == Reloc::PIC_) {
1338     OutStreamer->SwitchSection(
1339            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
1340                                       MachO::S_SYMBOL_STUBS |
1341                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1342                                       32, SectionKind::getText()));
1343   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
1344     OutStreamer->SwitchSection(
1345            OutContext.getMachOSection("__TEXT","__symbol_stub1",
1346                                       MachO::S_SYMBOL_STUBS |
1347                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1348                                       16, SectionKind::getText()));
1349   }
1350   OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
1351 }
1352
1353 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
1354   // Remove $stub suffix, add $lazy_ptr.
1355   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
1356   return Ctx.getOrCreateSymbol(NoStub + "$lazy_ptr");
1357 }
1358
1359 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
1360   // Add $tmp suffix to $stub, yielding $stub$tmp.
1361   return Ctx.getOrCreateSymbol(Sym->getName() + "$tmp");
1362 }
1363
1364 void PPCDarwinAsmPrinter::
1365 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
1366   bool isPPC64 = getDataLayout().getPointerSizeInBits() == 64;
1367
1368   // Construct a local MCSubtargetInfo and shadow EmitToStreamer here.
1369   // This is because the MachineFunction won't exist (but have not yet been
1370   // freed) and since we're at the global level we can use the default
1371   // constructed subtarget.
1372   std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
1373       TM.getTargetTriple().str(), TM.getTargetCPU(),
1374       TM.getTargetFeatureString()));
1375   auto EmitToStreamer = [&STI] (MCStreamer &S, const MCInst &Inst) {
1376     S.EmitInstruction(Inst, *STI);
1377   };
1378
1379   const TargetLoweringObjectFileMachO &TLOFMacho =
1380       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1381
1382   // .lazy_symbol_pointer
1383   MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
1384
1385   // Output stubs for dynamically-linked functions
1386   if (TM.getRelocationModel() == Reloc::PIC_) {
1387     MCSection *StubSection = OutContext.getMachOSection(
1388         "__TEXT", "__picsymbolstub1",
1389         MachO::S_SYMBOL_STUBS | MachO::S_ATTR_PURE_INSTRUCTIONS, 32,
1390         SectionKind::getText());
1391     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1392       OutStreamer->SwitchSection(StubSection);
1393       EmitAlignment(4);
1394
1395       MCSymbol *Stub = Stubs[i].first;
1396       MCSymbol *RawSym = Stubs[i].second.getPointer();
1397       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1398       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
1399
1400       OutStreamer->EmitLabel(Stub);
1401       OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1402
1403       const MCExpr *Anon = MCSymbolRefExpr::create(AnonSymbol, OutContext);
1404       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::create(LazyPtr, OutContext);
1405       const MCExpr *Sub =
1406         MCBinaryExpr::createSub(LazyPtrExpr, Anon, OutContext);
1407
1408       // mflr r0
1409       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
1410       // bcl 20, 31, AnonSymbol
1411       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCLalways).addExpr(Anon));
1412       OutStreamer->EmitLabel(AnonSymbol);
1413       // mflr r11
1414       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
1415       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
1416       const MCExpr *SubHa16 = PPCMCExpr::createHa(Sub, true, OutContext);
1417       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
1418         .addReg(PPC::R11)
1419         .addReg(PPC::R11)
1420         .addExpr(SubHa16));
1421       // mtlr r0
1422       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
1423
1424       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
1425       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
1426       const MCExpr *SubLo16 = PPCMCExpr::createLo(Sub, true, OutContext);
1427       EmitToStreamer(*OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1428         .addReg(PPC::R12)
1429         .addExpr(SubLo16).addExpr(SubLo16)
1430         .addReg(PPC::R11));
1431       // mtctr r12
1432       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1433       // bctr
1434       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTR));
1435
1436       OutStreamer->SwitchSection(LSPSection);
1437       OutStreamer->EmitLabel(LazyPtr);
1438       OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1439
1440       MCSymbol *DyldStubBindingHelper =
1441         OutContext.getOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1442       if (isPPC64) {
1443         // .quad dyld_stub_binding_helper
1444         OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 8);
1445       } else {
1446         // .long dyld_stub_binding_helper
1447         OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 4);
1448       }
1449     }
1450     OutStreamer->AddBlankLine();
1451     return;
1452   }
1453
1454   MCSection *StubSection = OutContext.getMachOSection(
1455       "__TEXT", "__symbol_stub1",
1456       MachO::S_SYMBOL_STUBS | MachO::S_ATTR_PURE_INSTRUCTIONS, 16,
1457       SectionKind::getText());
1458   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1459     MCSymbol *Stub = Stubs[i].first;
1460     MCSymbol *RawSym = Stubs[i].second.getPointer();
1461     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1462     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::create(LazyPtr, OutContext);
1463
1464     OutStreamer->SwitchSection(StubSection);
1465     EmitAlignment(4);
1466     OutStreamer->EmitLabel(Stub);
1467     OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1468
1469     // lis r11, ha16(LazyPtr)
1470     const MCExpr *LazyPtrHa16 =
1471       PPCMCExpr::createHa(LazyPtrExpr, true, OutContext);
1472     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LIS)
1473       .addReg(PPC::R11)
1474       .addExpr(LazyPtrHa16));
1475
1476     // ldu r12, lo16(LazyPtr)(r11)
1477     // lwzu r12, lo16(LazyPtr)(r11)
1478     const MCExpr *LazyPtrLo16 =
1479       PPCMCExpr::createLo(LazyPtrExpr, true, OutContext);
1480     EmitToStreamer(*OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1481       .addReg(PPC::R12)
1482       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
1483       .addReg(PPC::R11));
1484
1485     // mtctr r12
1486     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1487     // bctr
1488     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTR));
1489
1490     OutStreamer->SwitchSection(LSPSection);
1491     OutStreamer->EmitLabel(LazyPtr);
1492     OutStreamer->EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1493
1494     MCSymbol *DyldStubBindingHelper =
1495       OutContext.getOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1496     if (isPPC64) {
1497       // .quad dyld_stub_binding_helper
1498       OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 8);
1499     } else {
1500       // .long dyld_stub_binding_helper
1501       OutStreamer->EmitSymbolValue(DyldStubBindingHelper, 4);
1502     }
1503   }
1504
1505   OutStreamer->AddBlankLine();
1506 }
1507
1508 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1509   bool isPPC64 = getDataLayout().getPointerSizeInBits() == 64;
1510
1511   // Darwin/PPC always uses mach-o.
1512   const TargetLoweringObjectFileMachO &TLOFMacho =
1513       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1514   MachineModuleInfoMachO &MMIMacho =
1515       MMI->getObjFileInfo<MachineModuleInfoMachO>();
1516
1517   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1518   if (!Stubs.empty())
1519     EmitFunctionStubs(Stubs);
1520
1521   if (MAI->doesSupportExceptionHandling() && MMI) {
1522     // Add the (possibly multiple) personalities to the set of global values.
1523     // Only referenced functions get into the Personalities list.
1524     for (const Function *Personality : MMI->getPersonalities()) {
1525       if (Personality) {
1526         MCSymbol *NLPSym =
1527             getSymbolWithGlobalValueBase(Personality, "$non_lazy_ptr");
1528         MachineModuleInfoImpl::StubValueTy &StubSym =
1529             MMIMacho.getGVStubEntry(NLPSym);
1530         StubSym =
1531             MachineModuleInfoImpl::StubValueTy(getSymbol(Personality), true);
1532       }
1533     }
1534   }
1535
1536   // Output stubs for dynamically-linked functions.
1537   Stubs = MMIMacho.GetGVStubList();
1538
1539   // Output macho stubs for external and common global variables.
1540   if (!Stubs.empty()) {
1541     // Switch with ".non_lazy_symbol_pointer" directive.
1542     OutStreamer->SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1543     EmitAlignment(isPPC64 ? 3 : 2);
1544
1545     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1546       // L_foo$stub:
1547       OutStreamer->EmitLabel(Stubs[i].first);
1548       //   .indirect_symbol _foo
1549       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1550       OutStreamer->EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1551
1552       if (MCSym.getInt())
1553         // External to current translation unit.
1554         OutStreamer->EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1555       else
1556         // Internal to current translation unit.
1557         //
1558         // When we place the LSDA into the TEXT section, the type info pointers
1559         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1560         // However, sometimes the types are local to the file. So we need to
1561         // fill in the value for the NLP in those cases.
1562         OutStreamer->EmitValue(MCSymbolRefExpr::create(MCSym.getPointer(),
1563                                                        OutContext),
1564                               isPPC64 ? 8 : 4/*size*/);
1565     }
1566
1567     Stubs.clear();
1568     OutStreamer->AddBlankLine();
1569   }
1570
1571   Stubs = MMIMacho.GetHiddenGVStubList();
1572   if (!Stubs.empty()) {
1573     OutStreamer->SwitchSection(getObjFileLowering().getDataSection());
1574     EmitAlignment(isPPC64 ? 3 : 2);
1575
1576     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1577       // L_foo$stub:
1578       OutStreamer->EmitLabel(Stubs[i].first);
1579       //   .long _foo
1580       OutStreamer->EmitValue(MCSymbolRefExpr::
1581                              create(Stubs[i].second.getPointer(),
1582                                     OutContext),
1583                              isPPC64 ? 8 : 4/*size*/);
1584     }
1585
1586     Stubs.clear();
1587     OutStreamer->AddBlankLine();
1588   }
1589
1590   // Funny Darwin hack: This flag tells the linker that no global symbols
1591   // contain code that falls through to other global symbols (e.g. the obvious
1592   // implementation of multiple entry points).  If this doesn't occur, the
1593   // linker can safely perform dead code stripping.  Since LLVM never generates
1594   // code that does this, it is always safe to set.
1595   OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1596
1597   return AsmPrinter::doFinalization(M);
1598 }
1599
1600 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1601 /// for a MachineFunction to the given output stream, in a format that the
1602 /// Darwin assembler can deal with.
1603 ///
1604 static AsmPrinter *
1605 createPPCAsmPrinterPass(TargetMachine &tm,
1606                         std::unique_ptr<MCStreamer> &&Streamer) {
1607   if (tm.getTargetTriple().isMacOSX())
1608     return new PPCDarwinAsmPrinter(tm, std::move(Streamer));
1609   return new PPCLinuxAsmPrinter(tm, std::move(Streamer));
1610 }
1611
1612 // Force static initialization.
1613 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1614   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1615   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1616   TargetRegistry::RegisterAsmPrinter(ThePPC64LETarget, createPPCAsmPrinterPass);
1617 }