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