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