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