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