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 "PPCSubtarget.h"
  24 #include "PPCTargetMachine.h"
  25 #include "PPCTargetStreamer.h"
  26 #include "llvm/ADT/MapVector.h"
  27 #include "llvm/ADT/SmallString.h"
  28 #include "llvm/ADT/StringExtras.h"
  29 #include "llvm/CodeGen/AsmPrinter.h"
  30 #include "llvm/CodeGen/MachineFunctionPass.h"
  31 #include "llvm/CodeGen/MachineInstr.h"
  32 #include "llvm/CodeGen/MachineInstrBuilder.h"
  33 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
  34 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
  35 #include "llvm/IR/Constants.h"
  36 #include "llvm/IR/DebugInfo.h"
  37 #include "llvm/IR/DerivedTypes.h"
  38 #include "llvm/IR/Mangler.h"
  39 #include "llvm/IR/Module.h"
  40 #include "llvm/MC/MCAsmInfo.h"
  41 #include "llvm/MC/MCContext.h"
  42 #include "llvm/MC/MCExpr.h"
  43 #include "llvm/MC/MCInst.h"
  44 #include "llvm/MC/MCInstBuilder.h"
  45 #include "llvm/MC/MCSectionELF.h"
  46 #include "llvm/MC/MCSectionMachO.h"
  47 #include "llvm/MC/MCStreamer.h"
  48 #include "llvm/MC/MCSymbol.h"
  49 #include "llvm/Support/CommandLine.h"
  50 #include "llvm/Support/Debug.h"
  51 #include "llvm/Support/ELF.h"
  52 #include "llvm/Support/ErrorHandling.h"
  53 #include "llvm/Support/MathExtras.h"
  54 #include "llvm/Support/TargetRegistry.h"
  55 #include "llvm/Support/raw_ostream.h"
  56 #include "llvm/Target/TargetInstrInfo.h"
  57 #include "llvm/Target/TargetOptions.h"
  58 #include "llvm/Target/TargetRegisterInfo.h"
  59 using namespace llvm;
  60
  61 #define DEBUG_TYPE "asmprinter"
  62
  63 namespace {
  64   class PPCAsmPrinter : public AsmPrinter {
  65   protected:
  66     MapVector<MCSymbol*, MCSymbol*> TOC;
  67     const PPCSubtarget &Subtarget;
  68     uint64_t TOCLabelID;
  69   public:
  70     explicit PPCAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
  71       : AsmPrinter(TM, Streamer),
  72         Subtarget(TM.getSubtarget<PPCSubtarget>()), TOCLabelID(0) {}
  73
  74     const char *getPassName() const override {
  75       return "PowerPC Assembly Printer";
  76     }
  77
  78     MCSymbol *lookUpOrCreateTOCEntry(MCSymbol *Sym);
  79
  80     void EmitInstruction(const MachineInstr *MI) override;
  81
  82     void printOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
  83
  84     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
  85                          unsigned AsmVariant, const char *ExtraCode,
  86                          raw_ostream &O) override;
  87     bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
  88                                unsigned AsmVariant, const char *ExtraCode,
  89                                raw_ostream &O) override;
  90   };
  91
  92   /// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux
  93   class PPCLinuxAsmPrinter : public PPCAsmPrinter {
  94   public:
  95     explicit PPCLinuxAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
  96       : PPCAsmPrinter(TM, Streamer) {}
  97
  98     const char *getPassName() const override {
  99       return "Linux PPC Assembly Printer";
 100     }
 101
 102     bool doFinalization(Module &M) override;
 103
 104     void EmitFunctionEntryLabel() override;
 105
 106     void EmitFunctionBodyEnd() override;
 107   };
 108
 109   /// PPCDarwinAsmPrinter - PowerPC assembly printer, customized for Darwin/Mac
 110   /// OS X
 111   class PPCDarwinAsmPrinter : public PPCAsmPrinter {
 112   public:
 113     explicit PPCDarwinAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
 114       : PPCAsmPrinter(TM, Streamer) {}
 115
 116     const char *getPassName() const override {
 117       return "Darwin PPC Assembly Printer";
 118     }
 119
 120     bool doFinalization(Module &M) override;
 121     void EmitStartOfAsmFile(Module &M) override;
 122
 123     void EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs);
 124   };
 125 } // end of anonymous namespace
 126
 127 /// stripRegisterPrefix - This method strips the character prefix from a
 128 /// register name so that only the number is left.  Used by for linux asm.
 129 static const char *stripRegisterPrefix(const char *RegName) {
 130   switch (RegName[0]) {
 131     case 'r':
 132     case 'f':
 133     case 'v':
 134       if (RegName[1] == 's')
 135         return RegName + 2;
 136       return RegName + 1;
 137     case 'c': if (RegName[1] == 'r') return RegName + 2;
 138   }
 139
 140   return RegName;
 141 }
 142
 143 void PPCAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
 144                                  raw_ostream &O) {
 145   const DataLayout *DL = TM.getDataLayout();
 146   const MachineOperand &MO = MI->getOperand(OpNo);
 147
 148   switch (MO.getType()) {
 149   case MachineOperand::MO_Register: {
 150     const char *RegName = PPCInstPrinter::getRegisterName(MO.getReg());
 151     // Linux assembler (Others?) does not take register mnemonics.
 152     // FIXME - What about special registers used in mfspr/mtspr?
 153     if (!Subtarget.isDarwin()) RegName = stripRegisterPrefix(RegName);
 154     O << RegName;
 155     return;
 156   }
 157   case MachineOperand::MO_Immediate:
 158     O << MO.getImm();
 159     return;
 160
 161   case MachineOperand::MO_MachineBasicBlock:
 162     O << *MO.getMBB()->getSymbol();
 163     return;
 164   case MachineOperand::MO_ConstantPoolIndex:
 165     O << DL->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber()
 166       << '_' << MO.getIndex();
 167     return;
 168   case MachineOperand::MO_BlockAddress:
 169     O << *GetBlockAddressSymbol(MO.getBlockAddress());
 170     return;
 171   case MachineOperand::MO_GlobalAddress: {
 172     // Computing the address of a global symbol, not calling it.
 173     const GlobalValue *GV = MO.getGlobal();
 174     MCSymbol *SymToPrint;
 175
 176     // External or weakly linked global variables need non-lazily-resolved stubs
 177     if (TM.getRelocationModel() != Reloc::Static &&
 178         (GV->isDeclaration() || GV->isWeakForLinker())) {
 179       if (!GV->hasHiddenVisibility()) {
 180         SymToPrint = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
 181         MachineModuleInfoImpl::StubValueTy &StubSym =
 182           MMI->getObjFileInfo<MachineModuleInfoMachO>()
 183             .getGVStubEntry(SymToPrint);
 184         if (!StubSym.getPointer())
 185           StubSym = MachineModuleInfoImpl::
 186             StubValueTy(getSymbol(GV), !GV->hasInternalLinkage());
 187       } else if (GV->isDeclaration() || GV->hasCommonLinkage() ||
 188                  GV->hasAvailableExternallyLinkage()) {
 189         SymToPrint = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
 190
 191         MachineModuleInfoImpl::StubValueTy &StubSym =
 192           MMI->getObjFileInfo<MachineModuleInfoMachO>().
 193                     getHiddenGVStubEntry(SymToPrint);
 194         if (!StubSym.getPointer())
 195           StubSym = MachineModuleInfoImpl::
 196             StubValueTy(getSymbol(GV), !GV->hasInternalLinkage());
 197       } else {
 198         SymToPrint = getSymbol(GV);
 199       }
 200     } else {
 201       SymToPrint = getSymbol(GV);
 202     }
 203
 204     O << *SymToPrint;
 205
 206     printOffset(MO.getOffset(), O);
 207     return;
 208   }
 209
 210   default:
 211     O << "<unknown operand type: " << (unsigned)MO.getType() << ">";
 212     return;
 213   }
 214 }
 215
 216 /// PrintAsmOperand - Print out an operand for an inline asm expression.
 217 ///
 218 bool PPCAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
 219                                     unsigned AsmVariant,
 220                                     const char *ExtraCode, raw_ostream &O) {
 221   // Does this asm operand have a single letter operand modifier?
 222   if (ExtraCode && ExtraCode[0]) {
 223     if (ExtraCode[1] != 0) return true; // Unknown modifier.
 224
 225     switch (ExtraCode[0]) {
 226     default:
 227       // See if this is a generic print operand
 228       return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O);
 229     case 'c': // Don't print "$" before a global var name or constant.
 230       break; // PPC never has a prefix.
 231     case 'L': // Write second word of DImode reference.
 232       // Verify that this operand has two consecutive registers.
 233       if (!MI->getOperand(OpNo).isReg() ||
 234           OpNo+1 == MI->getNumOperands() ||
 235           !MI->getOperand(OpNo+1).isReg())
 236         return true;
 237       ++OpNo;   // Return the high-part.
 238       break;
 239     case 'I':
 240       // Write 'i' if an integer constant, otherwise nothing.  Used to print
 241       // addi vs add, etc.
 242       if (MI->getOperand(OpNo).isImm())
 243         O << "i";
 244       return false;
 245     }
 246   }
 247
 248   printOperand(MI, OpNo, O);
 249   return false;
 250 }
 251
 252 // At the moment, all inline asm memory operands are a single register.
 253 // In any case, the output of this routine should always be just one
 254 // assembler operand.
 255
 256 bool PPCAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
 257                                           unsigned AsmVariant,
 258                                           const char *ExtraCode,
 259                                           raw_ostream &O) {
 260   if (ExtraCode && ExtraCode[0]) {
 261     if (ExtraCode[1] != 0) return true; // Unknown modifier.
 262
 263     switch (ExtraCode[0]) {
 264     default: return true;  // Unknown modifier.
 265     case 'y': // A memory reference for an X-form instruction
 266       {
 267         const char *RegName = "r0";
 268         if (!Subtarget.isDarwin()) RegName = stripRegisterPrefix(RegName);
 269         O << RegName << ", ";
 270         printOperand(MI, OpNo, O);
 271         return false;
 272       }
 273     }
 274   }
 275
 276   assert(MI->getOperand(OpNo).isReg());
 277   O << "0(";
 278   printOperand(MI, OpNo, O);
 279   O << ")";
 280   return false;
 281 }
 282
 283
 284 /// lookUpOrCreateTOCEntry -- Given a symbol, look up whether a TOC entry
 285 /// exists for it.  If not, create one.  Then return a symbol that references
 286 /// the TOC entry.
 287 MCSymbol *PPCAsmPrinter::lookUpOrCreateTOCEntry(MCSymbol *Sym) {
 288   const DataLayout *DL = TM.getDataLayout();
 289   MCSymbol *&TOCEntry = TOC[Sym];
 290
 291   // To avoid name clash check if the name already exists.
 292   while (!TOCEntry) {
 293     if (OutContext.LookupSymbol(Twine(DL->getPrivateGlobalPrefix()) +
 294                                 "C" + Twine(TOCLabelID++)) == nullptr) {
 295       TOCEntry = GetTempSymbol("C", TOCLabelID);
 296     }
 297   }
 298
 299   return TOCEntry;
 300 }
 301
 302
 303 /// EmitInstruction -- Print out a single PowerPC MI in Darwin syntax to
 304 /// the current output stream.
 305 ///
 306 void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) {
 307   MCInst TmpInst;
 308   bool isPPC64 = Subtarget.isPPC64();
 309
 310   // Lower multi-instruction pseudo operations.
 311   switch (MI->getOpcode()) {
 312   default: break;
 313   case TargetOpcode::DBG_VALUE:
 314     llvm_unreachable("Should be handled target independently");
 315   case PPC::MovePCtoLR:
 316   case PPC::MovePCtoLR8: {
 317     // Transform %LR = MovePCtoLR
 318     // Into this, where the label is the PIC base:
 319     //     bl L1$pb
 320     // L1$pb:
 321     MCSymbol *PICBase = MF->getPICBaseSymbol();
 322
 323     // Emit the 'bl'.
 324     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL)
 325       // FIXME: We would like an efficient form for this, so we don't have to do
 326       // a lot of extra uniquing.
 327       .addExpr(MCSymbolRefExpr::Create(PICBase, OutContext)));
 328
 329     // Emit the label.
 330     OutStreamer.EmitLabel(PICBase);
 331     return;
 332   }
 333   case PPC::LDtocJTI:
 334   case PPC::LDtocCPT:
 335   case PPC::LDtoc: {
 336     // Transform %X3 = LDtoc <ga:@min1>, %X2
 337     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 338
 339     // Change the opcode to LD, and the global address operand to be a
 340     // reference to the TOC entry we will synthesize later.
 341     TmpInst.setOpcode(PPC::LD);
 342     const MachineOperand &MO = MI->getOperand(1);
 343
 344     // Map symbol -> label of TOC entry
 345     assert(MO.isGlobal() || MO.isCPI() || MO.isJTI());
 346     MCSymbol *MOSymbol = nullptr;
 347     if (MO.isGlobal())
 348       MOSymbol = getSymbol(MO.getGlobal());
 349     else if (MO.isCPI())
 350       MOSymbol = GetCPISymbol(MO.getIndex());
 351     else if (MO.isJTI())
 352       MOSymbol = GetJTISymbol(MO.getIndex());
 353
 354     MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol);
 355
 356     const MCExpr *Exp =
 357       MCSymbolRefExpr::Create(TOCEntry, MCSymbolRefExpr::VK_PPC_TOC,
 358                               OutContext);
 359     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 360     EmitToStreamer(OutStreamer, TmpInst);
 361     return;
 362   }
 363
 364   case PPC::ADDIStocHA: {
 365     // Transform %Xd = ADDIStocHA %X2, <ga:@sym>
 366     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 367
 368     // Change the opcode to ADDIS8.  If the global address is external,
 369     // has common linkage, is a function address, or is a jump table
 370     // address, then generate a TOC entry and reference that.  Otherwise
 371     // reference the symbol directly.
 372     TmpInst.setOpcode(PPC::ADDIS8);
 373     const MachineOperand &MO = MI->getOperand(2);
 374     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI()) &&
 375            "Invalid operand for ADDIStocHA!");
 376     MCSymbol *MOSymbol = nullptr;
 377     bool IsExternal = false;
 378     bool IsFunction = false;
 379     bool IsCommon = false;
 380     bool IsAvailExt = false;
 381
 382     if (MO.isGlobal()) {
 383       const GlobalValue *GValue = MO.getGlobal();
 384       const GlobalAlias *GAlias = dyn_cast<GlobalAlias>(GValue);
 385       const GlobalValue *RealGValue = GAlias ? GAlias->getAliasee() : GValue;
 386       MOSymbol = getSymbol(RealGValue);
 387       const GlobalVariable *GVar = dyn_cast<GlobalVariable>(RealGValue);
 388       IsExternal = GVar && !GVar->hasInitializer();
 389       IsCommon = GVar && RealGValue->hasCommonLinkage();
 390       IsFunction = !GVar;
 391       IsAvailExt = GVar && RealGValue->hasAvailableExternallyLinkage();
 392     } else if (MO.isCPI())
 393       MOSymbol = GetCPISymbol(MO.getIndex());
 394     else if (MO.isJTI())
 395       MOSymbol = GetJTISymbol(MO.getIndex());
 396
 397     if (IsExternal || IsFunction || IsCommon || IsAvailExt || MO.isJTI() ||
 398         TM.getCodeModel() == CodeModel::Large)
 399       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 400
 401     const MCExpr *Exp =
 402       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_HA,
 403                               OutContext);
 404     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
 405     EmitToStreamer(OutStreamer, TmpInst);
 406     return;
 407   }
 408   case PPC::LDtocL: {
 409     // Transform %Xd = LDtocL <ga:@sym>, %Xs
 410     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 411
 412     // Change the opcode to LD.  If the global address is external, has
 413     // common linkage, or is a jump table address, then reference the
 414     // associated TOC entry.  Otherwise reference the symbol directly.
 415     TmpInst.setOpcode(PPC::LD);
 416     const MachineOperand &MO = MI->getOperand(1);
 417     assert((MO.isGlobal() || MO.isJTI() || MO.isCPI()) &&
 418            "Invalid operand for LDtocL!");
 419     MCSymbol *MOSymbol = nullptr;
 420
 421     if (MO.isJTI())
 422       MOSymbol = lookUpOrCreateTOCEntry(GetJTISymbol(MO.getIndex()));
 423     else if (MO.isCPI()) {
 424       MOSymbol = GetCPISymbol(MO.getIndex());
 425       if (TM.getCodeModel() == CodeModel::Large)
 426         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 427     }
 428     else if (MO.isGlobal()) {
 429       const GlobalValue *GValue = MO.getGlobal();
 430       const GlobalAlias *GAlias = dyn_cast<GlobalAlias>(GValue);
 431       const GlobalValue *RealGValue = GAlias ? GAlias->getAliasee() : GValue;
 432       MOSymbol = getSymbol(RealGValue);
 433       const GlobalVariable *GVar = dyn_cast<GlobalVariable>(RealGValue);
 434
 435       if (!GVar || !GVar->hasInitializer() || RealGValue->hasCommonLinkage() ||
 436           RealGValue->hasAvailableExternallyLinkage() ||
 437           TM.getCodeModel() == CodeModel::Large)
 438         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 439     }
 440
 441     const MCExpr *Exp =
 442       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
 443                               OutContext);
 444     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 445     EmitToStreamer(OutStreamer, TmpInst);
 446     return;
 447   }
 448   case PPC::ADDItocL: {
 449     // Transform %Xd = ADDItocL %Xs, <ga:@sym>
 450     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 451
 452     // Change the opcode to ADDI8.  If the global address is external, then
 453     // generate a TOC entry and reference that.  Otherwise reference the
 454     // symbol directly.
 455     TmpInst.setOpcode(PPC::ADDI8);
 456     const MachineOperand &MO = MI->getOperand(2);
 457     assert((MO.isGlobal() || MO.isCPI()) && "Invalid operand for ADDItocL");
 458     MCSymbol *MOSymbol = nullptr;
 459     bool IsExternal = false;
 460     bool IsFunction = false;
 461
 462     if (MO.isGlobal()) {
 463       const GlobalValue *GValue = MO.getGlobal();
 464       const GlobalAlias *GAlias = dyn_cast<GlobalAlias>(GValue);
 465       const GlobalValue *RealGValue = GAlias ? GAlias->getAliasee() : GValue;
 466       MOSymbol = getSymbol(RealGValue);
 467       const GlobalVariable *GVar = dyn_cast<GlobalVariable>(RealGValue);
 468       IsExternal = GVar && !GVar->hasInitializer();
 469       IsFunction = !GVar;
 470     } else if (MO.isCPI())
 471       MOSymbol = GetCPISymbol(MO.getIndex());
 472
 473     if (IsFunction || IsExternal || TM.getCodeModel() == CodeModel::Large)
 474       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 475
 476     const MCExpr *Exp =
 477       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
 478                               OutContext);
 479     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
 480     EmitToStreamer(OutStreamer, TmpInst);
 481     return;
 482   }
 483   case PPC::ADDISgotTprelHA: {
 484     // Transform: %Xd = ADDISgotTprelHA %X2, <ga:@sym>
 485     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 486     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 487     const MachineOperand &MO = MI->getOperand(2);
 488     const GlobalValue *GValue = MO.getGlobal();
 489     MCSymbol *MOSymbol = getSymbol(GValue);
 490     const MCExpr *SymGotTprel =
 491       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA,
 492                               OutContext);
 493     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 494                                 .addReg(MI->getOperand(0).getReg())
 495                                 .addReg(PPC::X2)
 496                                 .addExpr(SymGotTprel));
 497     return;
 498   }
 499   case PPC::LDgotTprelL:
 500   case PPC::LDgotTprelL32: {
 501     // Transform %Xd = LDgotTprelL <ga:@sym>, %Xs
 502     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 503
 504     // Change the opcode to LD.
 505     TmpInst.setOpcode(isPPC64 ? PPC::LD : PPC::LWZ);
 506     const MachineOperand &MO = MI->getOperand(1);
 507     const GlobalValue *GValue = MO.getGlobal();
 508     MCSymbol *MOSymbol = getSymbol(GValue);
 509     const MCExpr *Exp =
 510       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO,
 511                               OutContext);
 512     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 513     EmitToStreamer(OutStreamer, TmpInst);
 514     return;
 515   }
 516
 517   case PPC::PPC32GOT: {
 518     MCSymbol *GOTSymbol = OutContext.GetOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
 519     const MCExpr *SymGotTlsL =
 520       MCSymbolRefExpr::Create(GOTSymbol, MCSymbolRefExpr::VK_PPC_LO,
 521                               OutContext);
 522     const MCExpr *SymGotTlsHA =
 523       MCSymbolRefExpr::Create(GOTSymbol, MCSymbolRefExpr::VK_PPC_HA,
 524                               OutContext);
 525     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LI)
 526                                 .addReg(MI->getOperand(0).getReg())
 527                                 .addExpr(SymGotTlsL));
 528     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
 529                                 .addReg(MI->getOperand(0).getReg())
 530                                 .addReg(MI->getOperand(0).getReg())
 531                                 .addExpr(SymGotTlsHA));
 532     return;
 533   }
 534   case PPC::ADDIStlsgdHA: {
 535     // Transform: %Xd = ADDIStlsgdHA %X2, <ga:@sym>
 536     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 537     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 538     const MachineOperand &MO = MI->getOperand(2);
 539     const GlobalValue *GValue = MO.getGlobal();
 540     MCSymbol *MOSymbol = getSymbol(GValue);
 541     const MCExpr *SymGotTlsGD =
 542       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA,
 543                               OutContext);
 544     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 545                                 .addReg(MI->getOperand(0).getReg())
 546                                 .addReg(PPC::X2)
 547                                 .addExpr(SymGotTlsGD));
 548     return;
 549   }
 550   case PPC::ADDItlsgdL: {
 551     // Transform: %Xd = ADDItlsgdL %Xs, <ga:@sym>
 552     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsgd@l
 553     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 554     const MachineOperand &MO = MI->getOperand(2);
 555     const GlobalValue *GValue = MO.getGlobal();
 556     MCSymbol *MOSymbol = getSymbol(GValue);
 557     const MCExpr *SymGotTlsGD =
 558       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO,
 559                               OutContext);
 560     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI8)
 561                                 .addReg(MI->getOperand(0).getReg())
 562                                 .addReg(MI->getOperand(1).getReg())
 563                                 .addExpr(SymGotTlsGD));
 564     return;
 565   }
 566   case PPC::GETtlsADDR: {
 567     // Transform: %X3 = GETtlsADDR %X3, <ga:@sym>
 568     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsgd)
 569     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 570
 571     StringRef Name = "__tls_get_addr";
 572     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 573     const MCSymbolRefExpr *TlsRef =
 574       MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);
 575     const MachineOperand &MO = MI->getOperand(2);
 576     const GlobalValue *GValue = MO.getGlobal();
 577     MCSymbol *MOSymbol = getSymbol(GValue);
 578     const MCExpr *SymVar =
 579       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSGD,
 580                               OutContext);
 581     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL8_NOP_TLS)
 582                                 .addExpr(TlsRef)
 583                                 .addExpr(SymVar));
 584     return;
 585   }
 586   case PPC::ADDIStlsldHA: {
 587     // Transform: %Xd = ADDIStlsldHA %X2, <ga:@sym>
 588     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsld@ha
 589     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 590     const MachineOperand &MO = MI->getOperand(2);
 591     const GlobalValue *GValue = MO.getGlobal();
 592     MCSymbol *MOSymbol = getSymbol(GValue);
 593     const MCExpr *SymGotTlsLD =
 594       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA,
 595                               OutContext);
 596     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 597                                 .addReg(MI->getOperand(0).getReg())
 598                                 .addReg(PPC::X2)
 599                                 .addExpr(SymGotTlsLD));
 600     return;
 601   }
 602   case PPC::ADDItlsldL: {
 603     // Transform: %Xd = ADDItlsldL %Xs, <ga:@sym>
 604     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsld@l
 605     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 606     const MachineOperand &MO = MI->getOperand(2);
 607     const GlobalValue *GValue = MO.getGlobal();
 608     MCSymbol *MOSymbol = getSymbol(GValue);
 609     const MCExpr *SymGotTlsLD =
 610       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO,
 611                               OutContext);
 612     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI8)
 613                                 .addReg(MI->getOperand(0).getReg())
 614                                 .addReg(MI->getOperand(1).getReg())
 615                                 .addExpr(SymGotTlsLD));
 616     return;
 617   }
 618   case PPC::GETtlsldADDR: {
 619     // Transform: %X3 = GETtlsldADDR %X3, <ga:@sym>
 620     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsld)
 621     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 622
 623     StringRef Name = "__tls_get_addr";
 624     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 625     const MCSymbolRefExpr *TlsRef =
 626       MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);
 627     const MachineOperand &MO = MI->getOperand(2);
 628     const GlobalValue *GValue = MO.getGlobal();
 629     MCSymbol *MOSymbol = getSymbol(GValue);
 630     const MCExpr *SymVar =
 631       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSLD,
 632                               OutContext);
 633     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL8_NOP_TLS)
 634                                 .addExpr(TlsRef)
 635                                 .addExpr(SymVar));
 636     return;
 637   }
 638   case PPC::ADDISdtprelHA: {
 639     // Transform: %Xd = ADDISdtprelHA %X3, <ga:@sym>
 640     // Into:      %Xd = ADDIS8 %X3, sym@dtprel@ha
 641     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 642     const MachineOperand &MO = MI->getOperand(2);
 643     const GlobalValue *GValue = MO.getGlobal();
 644     MCSymbol *MOSymbol = getSymbol(GValue);
 645     const MCExpr *SymDtprel =
 646       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_HA,
 647                               OutContext);
 648     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 649                                 .addReg(MI->getOperand(0).getReg())
 650                                 .addReg(PPC::X3)
 651                                 .addExpr(SymDtprel));
 652     return;
 653   }
 654   case PPC::ADDIdtprelL: {
 655     // Transform: %Xd = ADDIdtprelL %Xs, <ga:@sym>
 656     // Into:      %Xd = ADDI8 %Xs, sym@dtprel@l
 657     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 658     const MachineOperand &MO = MI->getOperand(2);
 659     const GlobalValue *GValue = MO.getGlobal();
 660     MCSymbol *MOSymbol = getSymbol(GValue);
 661     const MCExpr *SymDtprel =
 662       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_LO,
 663                               OutContext);
 664     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI8)
 665                                 .addReg(MI->getOperand(0).getReg())
 666                                 .addReg(MI->getOperand(1).getReg())
 667                                 .addExpr(SymDtprel));
 668     return;
 669   }
 670   case PPC::MFOCRF:
 671   case PPC::MFOCRF8:
 672     if (!Subtarget.hasMFOCRF()) {
 673       // Transform: %R3 = MFOCRF %CR7
 674       // Into:      %R3 = MFCR   ;; cr7
 675       unsigned NewOpcode =
 676         MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
 677       OutStreamer.AddComment(PPCInstPrinter::
 678                              getRegisterName(MI->getOperand(1).getReg()));
 679       EmitToStreamer(OutStreamer, MCInstBuilder(NewOpcode)
 680                                   .addReg(MI->getOperand(0).getReg()));
 681       return;
 682     }
 683     break;
 684   case PPC::MTOCRF:
 685   case PPC::MTOCRF8:
 686     if (!Subtarget.hasMFOCRF()) {
 687       // Transform: %CR7 = MTOCRF %R3
 688       // Into:      MTCRF mask, %R3 ;; cr7
 689       unsigned NewOpcode =
 690         MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
 691       unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
 692                               ->getEncodingValue(MI->getOperand(0).getReg());
 693       OutStreamer.AddComment(PPCInstPrinter::
 694                              getRegisterName(MI->getOperand(0).getReg()));
 695       EmitToStreamer(OutStreamer, MCInstBuilder(NewOpcode)
 696                                   .addImm(Mask)
 697                                   .addReg(MI->getOperand(1).getReg()));
 698       return;
 699     }
 700     break;
 701   case PPC::LD:
 702   case PPC::STD:
 703   case PPC::LWA_32:
 704   case PPC::LWA: {
 705     // Verify alignment is legal, so we don't create relocations
 706     // that can't be supported.
 707     // FIXME:  This test is currently disabled for Darwin.  The test
 708     // suite shows a handful of test cases that fail this check for
 709     // Darwin.  Those need to be investigated before this sanity test
 710     // can be enabled for those subtargets.
 711     if (!Subtarget.isDarwin()) {
 712       unsigned OpNum = (MI->getOpcode() == PPC::STD) ? 2 : 1;
 713       const MachineOperand &MO = MI->getOperand(OpNum);
 714       if (MO.isGlobal() && MO.getGlobal()->getAlignment() < 4)
 715         llvm_unreachable("Global must be word-aligned for LD, STD, LWA!");
 716     }
 717     // Now process the instruction normally.
 718     break;
 719   }
 720   }
 721
 722   LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 723   EmitToStreamer(OutStreamer, TmpInst);
 724 }
 725
 726 void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
 727   if (!Subtarget.isPPC64())  // linux/ppc32 - Normal entry label.
 728     return AsmPrinter::EmitFunctionEntryLabel();
 729
 730   // Emit an official procedure descriptor.
 731   MCSectionSubPair Current = OutStreamer.getCurrentSection();
 732   const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".opd",
 733       ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 734       SectionKind::getReadOnly());
 735   OutStreamer.SwitchSection(Section);
 736   OutStreamer.EmitLabel(CurrentFnSym);
 737   OutStreamer.EmitValueToAlignment(8);
 738   MCSymbol *Symbol1 =
 739     OutContext.GetOrCreateSymbol(".L." + Twine(CurrentFnSym->getName()));
 740   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
 741   // entry point.
 742   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol1, OutContext),
 743                         8 /*size*/);
 744   MCSymbol *Symbol2 = OutContext.GetOrCreateSymbol(StringRef(".TOC."));
 745   // Generates a R_PPC64_TOC relocation for TOC base insertion.
 746   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol2,
 747                         MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
 748                         8/*size*/);
 749   // Emit a null environment pointer.
 750   OutStreamer.EmitIntValue(0, 8 /* size */);
 751   OutStreamer.SwitchSection(Current.first, Current.second);
 752
 753   MCSymbol *RealFnSym = OutContext.GetOrCreateSymbol(
 754                           ".L." + Twine(CurrentFnSym->getName()));
 755   OutStreamer.EmitLabel(RealFnSym);
 756   CurrentFnSymForSize = RealFnSym;
 757 }
 758
 759
 760 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
 761   const DataLayout *TD = TM.getDataLayout();
 762
 763   bool isPPC64 = TD->getPointerSizeInBits() == 64;
 764
 765   PPCTargetStreamer &TS =
 766       static_cast<PPCTargetStreamer &>(*OutStreamer.getTargetStreamer());
 767
 768   if (isPPC64 && !TOC.empty()) {
 769     const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".toc",
 770         ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 771         SectionKind::getReadOnly());
 772     OutStreamer.SwitchSection(Section);
 773
 774     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
 775          E = TOC.end(); I != E; ++I) {
 776       OutStreamer.EmitLabel(I->second);
 777       MCSymbol *S = OutContext.GetOrCreateSymbol(I->first->getName());
 778       TS.emitTCEntry(*S);
 779     }
 780   }
 781
 782   MachineModuleInfoELF &MMIELF =
 783     MMI->getObjFileInfo<MachineModuleInfoELF>();
 784
 785   MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
 786   if (!Stubs.empty()) {
 787     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
 788     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 789       // L_foo$stub:
 790       OutStreamer.EmitLabel(Stubs[i].first);
 791       //   .long _foo
 792       OutStreamer.EmitValue(MCSymbolRefExpr::Create(Stubs[i].second.getPointer(),
 793                                                     OutContext),
 794                             isPPC64 ? 8 : 4/*size*/);
 795     }
 796
 797     Stubs.clear();
 798     OutStreamer.AddBlankLine();
 799   }
 800
 801   return AsmPrinter::doFinalization(M);
 802 }
 803
 804 /// EmitFunctionBodyEnd - Print the traceback table before the .size
 805 /// directive.
 806 ///
 807 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
 808   // Only the 64-bit target requires a traceback table.  For now,
 809   // we only emit the word of zeroes that GDB requires to find
 810   // the end of the function, and zeroes for the eight-byte
 811   // mandatory fields.
 812   // FIXME: We should fill in the eight-byte mandatory fields as described in
 813   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
 814   // currently make use of these fields).
 815   if (Subtarget.isPPC64()) {
 816     OutStreamer.EmitIntValue(0, 4/*size*/);
 817     OutStreamer.EmitIntValue(0, 8/*size*/);
 818   }
 819 }
 820
 821 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
 822   static const char *const CPUDirectives[] = {
 823     "",
 824     "ppc",
 825     "ppc440",
 826     "ppc601",
 827     "ppc602",
 828     "ppc603",
 829     "ppc7400",
 830     "ppc750",
 831     "ppc970",
 832     "ppcA2",
 833     "ppce500mc",
 834     "ppce5500",
 835     "power3",
 836     "power4",
 837     "power5",
 838     "power5x",
 839     "power6",
 840     "power6x",
 841     "power7",
 842     "ppc64",
 843     "ppc64le"
 844   };
 845
 846   unsigned Directive = Subtarget.getDarwinDirective();
 847   if (Subtarget.hasMFOCRF() && Directive < PPC::DIR_970)
 848     Directive = PPC::DIR_970;
 849   if (Subtarget.hasAltivec() && Directive < PPC::DIR_7400)
 850     Directive = PPC::DIR_7400;
 851   if (Subtarget.isPPC64() && Directive < PPC::DIR_64)
 852     Directive = PPC::DIR_64;
 853   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
 854
 855   assert(Directive < array_lengthof(CPUDirectives) &&
 856          "CPUDirectives[] might not be up-to-date!");
 857   PPCTargetStreamer &TStreamer =
 858       *static_cast<PPCTargetStreamer *>(OutStreamer.getTargetStreamer());
 859   TStreamer.emitMachine(CPUDirectives[Directive]);
 860
 861   // Prime text sections so they are adjacent.  This reduces the likelihood a
 862   // large data or debug section causes a branch to exceed 16M limit.
 863   const TargetLoweringObjectFileMachO &TLOFMacho =
 864     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
 865   OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection());
 866   if (TM.getRelocationModel() == Reloc::PIC_) {
 867     OutStreamer.SwitchSection(
 868            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
 869                                       MachO::S_SYMBOL_STUBS |
 870                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
 871                                       32, SectionKind::getText()));
 872   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
 873     OutStreamer.SwitchSection(
 874            OutContext.getMachOSection("__TEXT","__symbol_stub1",
 875                                       MachO::S_SYMBOL_STUBS |
 876                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
 877                                       16, SectionKind::getText()));
 878   }
 879   OutStreamer.SwitchSection(getObjFileLowering().getTextSection());
 880 }
 881
 882 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
 883   // Remove $stub suffix, add $lazy_ptr.
 884   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
 885   return Ctx.GetOrCreateSymbol(NoStub + "$lazy_ptr");
 886 }
 887
 888 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
 889   // Add $tmp suffix to $stub, yielding $stub$tmp.
 890   return Ctx.GetOrCreateSymbol(Sym->getName() + "$tmp");
 891 }
 892
 893 void PPCDarwinAsmPrinter::
 894 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
 895   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
 896   bool isDarwin = Subtarget.isDarwin();
 897
 898   const TargetLoweringObjectFileMachO &TLOFMacho =
 899     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
 900
 901   // .lazy_symbol_pointer
 902   const MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
 903
 904   // Output stubs for dynamically-linked functions
 905   if (TM.getRelocationModel() == Reloc::PIC_) {
 906     const MCSection *StubSection =
 907     OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
 908                                MachO::S_SYMBOL_STUBS |
 909                                MachO::S_ATTR_PURE_INSTRUCTIONS,
 910                                32, SectionKind::getText());
 911     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 912       OutStreamer.SwitchSection(StubSection);
 913       EmitAlignment(4);
 914
 915       MCSymbol *Stub = Stubs[i].first;
 916       MCSymbol *RawSym = Stubs[i].second.getPointer();
 917       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
 918       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
 919
 920       OutStreamer.EmitLabel(Stub);
 921       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
 922
 923       const MCExpr *Anon = MCSymbolRefExpr::Create(AnonSymbol, OutContext);
 924       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
 925       const MCExpr *Sub =
 926         MCBinaryExpr::CreateSub(LazyPtrExpr, Anon, OutContext);
 927
 928       // mflr r0
 929       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
 930       // bcl 20, 31, AnonSymbol
 931       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCLalways).addExpr(Anon));
 932       OutStreamer.EmitLabel(AnonSymbol);
 933       // mflr r11
 934       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
 935       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
 936       const MCExpr *SubHa16 = PPCMCExpr::CreateHa(Sub, isDarwin, OutContext);
 937       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
 938         .addReg(PPC::R11)
 939         .addReg(PPC::R11)
 940         .addExpr(SubHa16));
 941       // mtlr r0
 942       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
 943
 944       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
 945       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
 946       const MCExpr *SubLo16 = PPCMCExpr::CreateLo(Sub, isDarwin, OutContext);
 947       EmitToStreamer(OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
 948         .addReg(PPC::R12)
 949         .addExpr(SubLo16).addExpr(SubLo16)
 950         .addReg(PPC::R11));
 951       // mtctr r12
 952       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
 953       // bctr
 954       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCTR));
 955
 956       OutStreamer.SwitchSection(LSPSection);
 957       OutStreamer.EmitLabel(LazyPtr);
 958       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
 959
 960       MCSymbol *DyldStubBindingHelper =
 961         OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
 962       if (isPPC64) {
 963         // .quad dyld_stub_binding_helper
 964         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
 965       } else {
 966         // .long dyld_stub_binding_helper
 967         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
 968       }
 969     }
 970     OutStreamer.AddBlankLine();
 971     return;
 972   }
 973
 974   const MCSection *StubSection =
 975     OutContext.getMachOSection("__TEXT","__symbol_stub1",
 976                                MachO::S_SYMBOL_STUBS |
 977                                MachO::S_ATTR_PURE_INSTRUCTIONS,
 978                                16, SectionKind::getText());
 979   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 980     MCSymbol *Stub = Stubs[i].first;
 981     MCSymbol *RawSym = Stubs[i].second.getPointer();
 982     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
 983     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
 984
 985     OutStreamer.SwitchSection(StubSection);
 986     EmitAlignment(4);
 987     OutStreamer.EmitLabel(Stub);
 988     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
 989
 990     // lis r11, ha16(LazyPtr)
 991     const MCExpr *LazyPtrHa16 =
 992       PPCMCExpr::CreateHa(LazyPtrExpr, isDarwin, OutContext);
 993     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LIS)
 994       .addReg(PPC::R11)
 995       .addExpr(LazyPtrHa16));
 996
 997     // ldu r12, lo16(LazyPtr)(r11)
 998     // lwzu r12, lo16(LazyPtr)(r11)
 999     const MCExpr *LazyPtrLo16 =
1000       PPCMCExpr::CreateLo(LazyPtrExpr, isDarwin, OutContext);
1001     EmitToStreamer(OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1002       .addReg(PPC::R12)
1003       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
1004       .addReg(PPC::R11));
1005
1006     // mtctr r12
1007     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1008     // bctr
1009     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCTR));
1010
1011     OutStreamer.SwitchSection(LSPSection);
1012     OutStreamer.EmitLabel(LazyPtr);
1013     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1014
1015     MCSymbol *DyldStubBindingHelper =
1016       OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1017     if (isPPC64) {
1018       // .quad dyld_stub_binding_helper
1019       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
1020     } else {
1021       // .long dyld_stub_binding_helper
1022       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
1023     }
1024   }
1025
1026   OutStreamer.AddBlankLine();
1027 }
1028
1029
1030 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1031   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
1032
1033   // Darwin/PPC always uses mach-o.
1034   const TargetLoweringObjectFileMachO &TLOFMacho =
1035     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1036   MachineModuleInfoMachO &MMIMacho =
1037     MMI->getObjFileInfo<MachineModuleInfoMachO>();
1038
1039   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1040   if (!Stubs.empty())
1041     EmitFunctionStubs(Stubs);
1042
1043   if (MAI->doesSupportExceptionHandling() && MMI) {
1044     // Add the (possibly multiple) personalities to the set of global values.
1045     // Only referenced functions get into the Personalities list.
1046     const std::vector<const Function*> &Personalities = MMI->getPersonalities();
1047     for (std::vector<const Function*>::const_iterator I = Personalities.begin(),
1048          E = Personalities.end(); I != E; ++I) {
1049       if (*I) {
1050         MCSymbol *NLPSym = getSymbolWithGlobalValueBase(*I, "$non_lazy_ptr");
1051         MachineModuleInfoImpl::StubValueTy &StubSym =
1052           MMIMacho.getGVStubEntry(NLPSym);
1053         StubSym = MachineModuleInfoImpl::StubValueTy(getSymbol(*I), true);
1054       }
1055     }
1056   }
1057
1058   // Output stubs for dynamically-linked functions.
1059   Stubs = MMIMacho.GetGVStubList();
1060
1061   // Output macho stubs for external and common global variables.
1062   if (!Stubs.empty()) {
1063     // Switch with ".non_lazy_symbol_pointer" directive.
1064     OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1065     EmitAlignment(isPPC64 ? 3 : 2);
1066
1067     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1068       // L_foo$stub:
1069       OutStreamer.EmitLabel(Stubs[i].first);
1070       //   .indirect_symbol _foo
1071       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1072       OutStreamer.EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1073
1074       if (MCSym.getInt())
1075         // External to current translation unit.
1076         OutStreamer.EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1077       else
1078         // Internal to current translation unit.
1079         //
1080         // When we place the LSDA into the TEXT section, the type info pointers
1081         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1082         // However, sometimes the types are local to the file. So we need to
1083         // fill in the value for the NLP in those cases.
1084         OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(),
1085                                                       OutContext),
1086                               isPPC64 ? 8 : 4/*size*/);
1087     }
1088
1089     Stubs.clear();
1090     OutStreamer.AddBlankLine();
1091   }
1092
1093   Stubs = MMIMacho.GetHiddenGVStubList();
1094   if (!Stubs.empty()) {
1095     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
1096     EmitAlignment(isPPC64 ? 3 : 2);
1097
1098     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1099       // L_foo$stub:
1100       OutStreamer.EmitLabel(Stubs[i].first);
1101       //   .long _foo
1102       OutStreamer.EmitValue(MCSymbolRefExpr::
1103                             Create(Stubs[i].second.getPointer(),
1104                                    OutContext),
1105                             isPPC64 ? 8 : 4/*size*/);
1106     }
1107
1108     Stubs.clear();
1109     OutStreamer.AddBlankLine();
1110   }
1111
1112   // Funny Darwin hack: This flag tells the linker that no global symbols
1113   // contain code that falls through to other global symbols (e.g. the obvious
1114   // implementation of multiple entry points).  If this doesn't occur, the
1115   // linker can safely perform dead code stripping.  Since LLVM never generates
1116   // code that does this, it is always safe to set.
1117   OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1118
1119   return AsmPrinter::doFinalization(M);
1120 }
1121
1122 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1123 /// for a MachineFunction to the given output stream, in a format that the
1124 /// Darwin assembler can deal with.
1125 ///
1126 static AsmPrinter *createPPCAsmPrinterPass(TargetMachine &tm,
1127                                            MCStreamer &Streamer) {
1128   const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();
1129
1130   if (Subtarget->isDarwin())
1131     return new PPCDarwinAsmPrinter(tm, Streamer);
1132   return new PPCLinuxAsmPrinter(tm, Streamer);
1133 }
1134
1135 // Force static initialization.
1136 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1137   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1138   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1139   TargetRegistry::RegisterAsmPrinter(ThePPC64LETarget, createPPCAsmPrinterPass);
1140 }