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 *GV = MO.getGlobal();
 384       MOSymbol = getSymbol(GV);
 385       IsExternal = GV->isDeclaration();
 386       IsCommon = GV->hasCommonLinkage();
 387       IsFunction = GV->getType()->getElementType()->isFunctionTy();
 388       IsAvailExt = GV->hasAvailableExternallyLinkage();
 389     } else if (MO.isCPI())
 390       MOSymbol = GetCPISymbol(MO.getIndex());
 391     else if (MO.isJTI())
 392       MOSymbol = GetJTISymbol(MO.getIndex());
 393
 394     if (IsExternal || IsFunction || IsCommon || IsAvailExt || MO.isJTI() ||
 395         TM.getCodeModel() == CodeModel::Large)
 396       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 397
 398     const MCExpr *Exp =
 399       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_HA,
 400                               OutContext);
 401     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
 402     EmitToStreamer(OutStreamer, TmpInst);
 403     return;
 404   }
 405   case PPC::LDtocL: {
 406     // Transform %Xd = LDtocL <ga:@sym>, %Xs
 407     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 408
 409     // Change the opcode to LD.  If the global address is external, has
 410     // common linkage, or is a jump table address, then reference the
 411     // associated TOC entry.  Otherwise reference the symbol directly.
 412     TmpInst.setOpcode(PPC::LD);
 413     const MachineOperand &MO = MI->getOperand(1);
 414     assert((MO.isGlobal() || MO.isJTI() || MO.isCPI()) &&
 415            "Invalid operand for LDtocL!");
 416     MCSymbol *MOSymbol = nullptr;
 417
 418     if (MO.isJTI())
 419       MOSymbol = lookUpOrCreateTOCEntry(GetJTISymbol(MO.getIndex()));
 420     else if (MO.isCPI()) {
 421       MOSymbol = GetCPISymbol(MO.getIndex());
 422       if (TM.getCodeModel() == CodeModel::Large)
 423         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 424     }
 425     else if (MO.isGlobal()) {
 426       const GlobalValue *GValue = MO.getGlobal();
 427       MOSymbol = getSymbol(GValue);
 428       if (GValue->getType()->getElementType()->isFunctionTy() ||
 429           GValue->isDeclaration() || GValue->hasCommonLinkage() ||
 430           GValue->hasAvailableExternallyLinkage() ||
 431           TM.getCodeModel() == CodeModel::Large)
 432         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 433     }
 434
 435     const MCExpr *Exp =
 436       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
 437                               OutContext);
 438     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 439     EmitToStreamer(OutStreamer, TmpInst);
 440     return;
 441   }
 442   case PPC::ADDItocL: {
 443     // Transform %Xd = ADDItocL %Xs, <ga:@sym>
 444     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 445
 446     // Change the opcode to ADDI8.  If the global address is external, then
 447     // generate a TOC entry and reference that.  Otherwise reference the
 448     // symbol directly.
 449     TmpInst.setOpcode(PPC::ADDI8);
 450     const MachineOperand &MO = MI->getOperand(2);
 451     assert((MO.isGlobal() || MO.isCPI()) && "Invalid operand for ADDItocL");
 452     MCSymbol *MOSymbol = nullptr;
 453     bool IsExternal = false;
 454     bool IsFunction = false;
 455
 456     if (MO.isGlobal()) {
 457       const GlobalValue *GV = MO.getGlobal();
 458       MOSymbol = getSymbol(GV);
 459       IsExternal = GV->isDeclaration();
 460       IsFunction = GV->getType()->getElementType()->isFunctionTy();
 461     } else if (MO.isCPI())
 462       MOSymbol = GetCPISymbol(MO.getIndex());
 463
 464     if (IsFunction || IsExternal || TM.getCodeModel() == CodeModel::Large)
 465       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 466
 467     const MCExpr *Exp =
 468       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
 469                               OutContext);
 470     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
 471     EmitToStreamer(OutStreamer, TmpInst);
 472     return;
 473   }
 474   case PPC::ADDISgotTprelHA: {
 475     // Transform: %Xd = ADDISgotTprelHA %X2, <ga:@sym>
 476     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 477     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 478     const MachineOperand &MO = MI->getOperand(2);
 479     const GlobalValue *GValue = MO.getGlobal();
 480     MCSymbol *MOSymbol = getSymbol(GValue);
 481     const MCExpr *SymGotTprel =
 482       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA,
 483                               OutContext);
 484     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 485                                 .addReg(MI->getOperand(0).getReg())
 486                                 .addReg(PPC::X2)
 487                                 .addExpr(SymGotTprel));
 488     return;
 489   }
 490   case PPC::LDgotTprelL:
 491   case PPC::LDgotTprelL32: {
 492     // Transform %Xd = LDgotTprelL <ga:@sym>, %Xs
 493     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 494
 495     // Change the opcode to LD.
 496     TmpInst.setOpcode(isPPC64 ? PPC::LD : PPC::LWZ);
 497     const MachineOperand &MO = MI->getOperand(1);
 498     const GlobalValue *GValue = MO.getGlobal();
 499     MCSymbol *MOSymbol = getSymbol(GValue);
 500     const MCExpr *Exp =
 501       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO,
 502                               OutContext);
 503     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 504     EmitToStreamer(OutStreamer, TmpInst);
 505     return;
 506   }
 507
 508   case PPC::PPC32GOT: {
 509     MCSymbol *GOTSymbol = OutContext.GetOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
 510     const MCExpr *SymGotTlsL =
 511       MCSymbolRefExpr::Create(GOTSymbol, MCSymbolRefExpr::VK_PPC_LO,
 512                               OutContext);
 513     const MCExpr *SymGotTlsHA =
 514       MCSymbolRefExpr::Create(GOTSymbol, MCSymbolRefExpr::VK_PPC_HA,
 515                               OutContext);
 516     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LI)
 517                                 .addReg(MI->getOperand(0).getReg())
 518                                 .addExpr(SymGotTlsL));
 519     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
 520                                 .addReg(MI->getOperand(0).getReg())
 521                                 .addReg(MI->getOperand(0).getReg())
 522                                 .addExpr(SymGotTlsHA));
 523     return;
 524   }
 525   case PPC::ADDIStlsgdHA: {
 526     // Transform: %Xd = ADDIStlsgdHA %X2, <ga:@sym>
 527     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 528     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 529     const MachineOperand &MO = MI->getOperand(2);
 530     const GlobalValue *GValue = MO.getGlobal();
 531     MCSymbol *MOSymbol = getSymbol(GValue);
 532     const MCExpr *SymGotTlsGD =
 533       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA,
 534                               OutContext);
 535     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 536                                 .addReg(MI->getOperand(0).getReg())
 537                                 .addReg(PPC::X2)
 538                                 .addExpr(SymGotTlsGD));
 539     return;
 540   }
 541   case PPC::ADDItlsgdL: {
 542     // Transform: %Xd = ADDItlsgdL %Xs, <ga:@sym>
 543     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsgd@l
 544     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 545     const MachineOperand &MO = MI->getOperand(2);
 546     const GlobalValue *GValue = MO.getGlobal();
 547     MCSymbol *MOSymbol = getSymbol(GValue);
 548     const MCExpr *SymGotTlsGD =
 549       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO,
 550                               OutContext);
 551     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI8)
 552                                 .addReg(MI->getOperand(0).getReg())
 553                                 .addReg(MI->getOperand(1).getReg())
 554                                 .addExpr(SymGotTlsGD));
 555     return;
 556   }
 557   case PPC::GETtlsADDR: {
 558     // Transform: %X3 = GETtlsADDR %X3, <ga:@sym>
 559     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsgd)
 560     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 561
 562     StringRef Name = "__tls_get_addr";
 563     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 564     const MCSymbolRefExpr *TlsRef =
 565       MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);
 566     const MachineOperand &MO = MI->getOperand(2);
 567     const GlobalValue *GValue = MO.getGlobal();
 568     MCSymbol *MOSymbol = getSymbol(GValue);
 569     const MCExpr *SymVar =
 570       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSGD,
 571                               OutContext);
 572     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL8_NOP_TLS)
 573                                 .addExpr(TlsRef)
 574                                 .addExpr(SymVar));
 575     return;
 576   }
 577   case PPC::ADDIStlsldHA: {
 578     // Transform: %Xd = ADDIStlsldHA %X2, <ga:@sym>
 579     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsld@ha
 580     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 581     const MachineOperand &MO = MI->getOperand(2);
 582     const GlobalValue *GValue = MO.getGlobal();
 583     MCSymbol *MOSymbol = getSymbol(GValue);
 584     const MCExpr *SymGotTlsLD =
 585       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA,
 586                               OutContext);
 587     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 588                                 .addReg(MI->getOperand(0).getReg())
 589                                 .addReg(PPC::X2)
 590                                 .addExpr(SymGotTlsLD));
 591     return;
 592   }
 593   case PPC::ADDItlsldL: {
 594     // Transform: %Xd = ADDItlsldL %Xs, <ga:@sym>
 595     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsld@l
 596     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 597     const MachineOperand &MO = MI->getOperand(2);
 598     const GlobalValue *GValue = MO.getGlobal();
 599     MCSymbol *MOSymbol = getSymbol(GValue);
 600     const MCExpr *SymGotTlsLD =
 601       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO,
 602                               OutContext);
 603     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI8)
 604                                 .addReg(MI->getOperand(0).getReg())
 605                                 .addReg(MI->getOperand(1).getReg())
 606                                 .addExpr(SymGotTlsLD));
 607     return;
 608   }
 609   case PPC::GETtlsldADDR: {
 610     // Transform: %X3 = GETtlsldADDR %X3, <ga:@sym>
 611     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsld)
 612     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 613
 614     StringRef Name = "__tls_get_addr";
 615     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 616     const MCSymbolRefExpr *TlsRef =
 617       MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);
 618     const MachineOperand &MO = MI->getOperand(2);
 619     const GlobalValue *GValue = MO.getGlobal();
 620     MCSymbol *MOSymbol = getSymbol(GValue);
 621     const MCExpr *SymVar =
 622       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSLD,
 623                               OutContext);
 624     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL8_NOP_TLS)
 625                                 .addExpr(TlsRef)
 626                                 .addExpr(SymVar));
 627     return;
 628   }
 629   case PPC::ADDISdtprelHA: {
 630     // Transform: %Xd = ADDISdtprelHA %X3, <ga:@sym>
 631     // Into:      %Xd = ADDIS8 %X3, sym@dtprel@ha
 632     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 633     const MachineOperand &MO = MI->getOperand(2);
 634     const GlobalValue *GValue = MO.getGlobal();
 635     MCSymbol *MOSymbol = getSymbol(GValue);
 636     const MCExpr *SymDtprel =
 637       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_HA,
 638                               OutContext);
 639     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 640                                 .addReg(MI->getOperand(0).getReg())
 641                                 .addReg(PPC::X3)
 642                                 .addExpr(SymDtprel));
 643     return;
 644   }
 645   case PPC::ADDIdtprelL: {
 646     // Transform: %Xd = ADDIdtprelL %Xs, <ga:@sym>
 647     // Into:      %Xd = ADDI8 %Xs, sym@dtprel@l
 648     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 649     const MachineOperand &MO = MI->getOperand(2);
 650     const GlobalValue *GValue = MO.getGlobal();
 651     MCSymbol *MOSymbol = getSymbol(GValue);
 652     const MCExpr *SymDtprel =
 653       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_LO,
 654                               OutContext);
 655     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI8)
 656                                 .addReg(MI->getOperand(0).getReg())
 657                                 .addReg(MI->getOperand(1).getReg())
 658                                 .addExpr(SymDtprel));
 659     return;
 660   }
 661   case PPC::MFOCRF:
 662   case PPC::MFOCRF8:
 663     if (!Subtarget.hasMFOCRF()) {
 664       // Transform: %R3 = MFOCRF %CR7
 665       // Into:      %R3 = MFCR   ;; cr7
 666       unsigned NewOpcode =
 667         MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
 668       OutStreamer.AddComment(PPCInstPrinter::
 669                              getRegisterName(MI->getOperand(1).getReg()));
 670       EmitToStreamer(OutStreamer, MCInstBuilder(NewOpcode)
 671                                   .addReg(MI->getOperand(0).getReg()));
 672       return;
 673     }
 674     break;
 675   case PPC::MTOCRF:
 676   case PPC::MTOCRF8:
 677     if (!Subtarget.hasMFOCRF()) {
 678       // Transform: %CR7 = MTOCRF %R3
 679       // Into:      MTCRF mask, %R3 ;; cr7
 680       unsigned NewOpcode =
 681         MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
 682       unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
 683                               ->getEncodingValue(MI->getOperand(0).getReg());
 684       OutStreamer.AddComment(PPCInstPrinter::
 685                              getRegisterName(MI->getOperand(0).getReg()));
 686       EmitToStreamer(OutStreamer, MCInstBuilder(NewOpcode)
 687                                   .addImm(Mask)
 688                                   .addReg(MI->getOperand(1).getReg()));
 689       return;
 690     }
 691     break;
 692   case PPC::LD:
 693   case PPC::STD:
 694   case PPC::LWA_32:
 695   case PPC::LWA: {
 696     // Verify alignment is legal, so we don't create relocations
 697     // that can't be supported.
 698     // FIXME:  This test is currently disabled for Darwin.  The test
 699     // suite shows a handful of test cases that fail this check for
 700     // Darwin.  Those need to be investigated before this sanity test
 701     // can be enabled for those subtargets.
 702     if (!Subtarget.isDarwin()) {
 703       unsigned OpNum = (MI->getOpcode() == PPC::STD) ? 2 : 1;
 704       const MachineOperand &MO = MI->getOperand(OpNum);
 705       if (MO.isGlobal() && MO.getGlobal()->getAlignment() < 4)
 706         llvm_unreachable("Global must be word-aligned for LD, STD, LWA!");
 707     }
 708     // Now process the instruction normally.
 709     break;
 710   }
 711   }
 712
 713   LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 714   EmitToStreamer(OutStreamer, TmpInst);
 715 }
 716
 717 void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
 718   if (!Subtarget.isPPC64())  // linux/ppc32 - Normal entry label.
 719     return AsmPrinter::EmitFunctionEntryLabel();
 720
 721   // Emit an official procedure descriptor.
 722   MCSectionSubPair Current = OutStreamer.getCurrentSection();
 723   const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".opd",
 724       ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 725       SectionKind::getReadOnly());
 726   OutStreamer.SwitchSection(Section);
 727   OutStreamer.EmitLabel(CurrentFnSym);
 728   OutStreamer.EmitValueToAlignment(8);
 729   MCSymbol *Symbol1 =
 730     OutContext.GetOrCreateSymbol(".L." + Twine(CurrentFnSym->getName()));
 731   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
 732   // entry point.
 733   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol1, OutContext),
 734                         8 /*size*/);
 735   MCSymbol *Symbol2 = OutContext.GetOrCreateSymbol(StringRef(".TOC."));
 736   // Generates a R_PPC64_TOC relocation for TOC base insertion.
 737   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol2,
 738                         MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
 739                         8/*size*/);
 740   // Emit a null environment pointer.
 741   OutStreamer.EmitIntValue(0, 8 /* size */);
 742   OutStreamer.SwitchSection(Current.first, Current.second);
 743
 744   MCSymbol *RealFnSym = OutContext.GetOrCreateSymbol(
 745                           ".L." + Twine(CurrentFnSym->getName()));
 746   OutStreamer.EmitLabel(RealFnSym);
 747   CurrentFnSymForSize = RealFnSym;
 748 }
 749
 750
 751 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
 752   const DataLayout *TD = TM.getDataLayout();
 753
 754   bool isPPC64 = TD->getPointerSizeInBits() == 64;
 755
 756   PPCTargetStreamer &TS =
 757       static_cast<PPCTargetStreamer &>(*OutStreamer.getTargetStreamer());
 758
 759   if (isPPC64 && !TOC.empty()) {
 760     const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".toc",
 761         ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 762         SectionKind::getReadOnly());
 763     OutStreamer.SwitchSection(Section);
 764
 765     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
 766          E = TOC.end(); I != E; ++I) {
 767       OutStreamer.EmitLabel(I->second);
 768       MCSymbol *S = OutContext.GetOrCreateSymbol(I->first->getName());
 769       TS.emitTCEntry(*S);
 770     }
 771   }
 772
 773   MachineModuleInfoELF &MMIELF =
 774     MMI->getObjFileInfo<MachineModuleInfoELF>();
 775
 776   MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
 777   if (!Stubs.empty()) {
 778     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
 779     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 780       // L_foo$stub:
 781       OutStreamer.EmitLabel(Stubs[i].first);
 782       //   .long _foo
 783       OutStreamer.EmitValue(MCSymbolRefExpr::Create(Stubs[i].second.getPointer(),
 784                                                     OutContext),
 785                             isPPC64 ? 8 : 4/*size*/);
 786     }
 787
 788     Stubs.clear();
 789     OutStreamer.AddBlankLine();
 790   }
 791
 792   return AsmPrinter::doFinalization(M);
 793 }
 794
 795 /// EmitFunctionBodyEnd - Print the traceback table before the .size
 796 /// directive.
 797 ///
 798 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
 799   // Only the 64-bit target requires a traceback table.  For now,
 800   // we only emit the word of zeroes that GDB requires to find
 801   // the end of the function, and zeroes for the eight-byte
 802   // mandatory fields.
 803   // FIXME: We should fill in the eight-byte mandatory fields as described in
 804   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
 805   // currently make use of these fields).
 806   if (Subtarget.isPPC64()) {
 807     OutStreamer.EmitIntValue(0, 4/*size*/);
 808     OutStreamer.EmitIntValue(0, 8/*size*/);
 809   }
 810 }
 811
 812 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
 813   static const char *const CPUDirectives[] = {
 814     "",
 815     "ppc",
 816     "ppc440",
 817     "ppc601",
 818     "ppc602",
 819     "ppc603",
 820     "ppc7400",
 821     "ppc750",
 822     "ppc970",
 823     "ppcA2",
 824     "ppce500mc",
 825     "ppce5500",
 826     "power3",
 827     "power4",
 828     "power5",
 829     "power5x",
 830     "power6",
 831     "power6x",
 832     "power7",
 833     "ppc64",
 834     "ppc64le"
 835   };
 836
 837   unsigned Directive = Subtarget.getDarwinDirective();
 838   if (Subtarget.hasMFOCRF() && Directive < PPC::DIR_970)
 839     Directive = PPC::DIR_970;
 840   if (Subtarget.hasAltivec() && Directive < PPC::DIR_7400)
 841     Directive = PPC::DIR_7400;
 842   if (Subtarget.isPPC64() && Directive < PPC::DIR_64)
 843     Directive = PPC::DIR_64;
 844   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
 845
 846   assert(Directive < array_lengthof(CPUDirectives) &&
 847          "CPUDirectives[] might not be up-to-date!");
 848   PPCTargetStreamer &TStreamer =
 849       *static_cast<PPCTargetStreamer *>(OutStreamer.getTargetStreamer());
 850   TStreamer.emitMachine(CPUDirectives[Directive]);
 851
 852   // Prime text sections so they are adjacent.  This reduces the likelihood a
 853   // large data or debug section causes a branch to exceed 16M limit.
 854   const TargetLoweringObjectFileMachO &TLOFMacho =
 855     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
 856   OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection());
 857   if (TM.getRelocationModel() == Reloc::PIC_) {
 858     OutStreamer.SwitchSection(
 859            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
 860                                       MachO::S_SYMBOL_STUBS |
 861                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
 862                                       32, SectionKind::getText()));
 863   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
 864     OutStreamer.SwitchSection(
 865            OutContext.getMachOSection("__TEXT","__symbol_stub1",
 866                                       MachO::S_SYMBOL_STUBS |
 867                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
 868                                       16, SectionKind::getText()));
 869   }
 870   OutStreamer.SwitchSection(getObjFileLowering().getTextSection());
 871 }
 872
 873 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
 874   // Remove $stub suffix, add $lazy_ptr.
 875   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
 876   return Ctx.GetOrCreateSymbol(NoStub + "$lazy_ptr");
 877 }
 878
 879 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
 880   // Add $tmp suffix to $stub, yielding $stub$tmp.
 881   return Ctx.GetOrCreateSymbol(Sym->getName() + "$tmp");
 882 }
 883
 884 void PPCDarwinAsmPrinter::
 885 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
 886   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
 887   bool isDarwin = Subtarget.isDarwin();
 888
 889   const TargetLoweringObjectFileMachO &TLOFMacho =
 890     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
 891
 892   // .lazy_symbol_pointer
 893   const MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
 894
 895   // Output stubs for dynamically-linked functions
 896   if (TM.getRelocationModel() == Reloc::PIC_) {
 897     const MCSection *StubSection =
 898     OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
 899                                MachO::S_SYMBOL_STUBS |
 900                                MachO::S_ATTR_PURE_INSTRUCTIONS,
 901                                32, SectionKind::getText());
 902     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 903       OutStreamer.SwitchSection(StubSection);
 904       EmitAlignment(4);
 905
 906       MCSymbol *Stub = Stubs[i].first;
 907       MCSymbol *RawSym = Stubs[i].second.getPointer();
 908       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
 909       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
 910
 911       OutStreamer.EmitLabel(Stub);
 912       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
 913
 914       const MCExpr *Anon = MCSymbolRefExpr::Create(AnonSymbol, OutContext);
 915       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
 916       const MCExpr *Sub =
 917         MCBinaryExpr::CreateSub(LazyPtrExpr, Anon, OutContext);
 918
 919       // mflr r0
 920       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
 921       // bcl 20, 31, AnonSymbol
 922       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCLalways).addExpr(Anon));
 923       OutStreamer.EmitLabel(AnonSymbol);
 924       // mflr r11
 925       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
 926       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
 927       const MCExpr *SubHa16 = PPCMCExpr::CreateHa(Sub, isDarwin, OutContext);
 928       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
 929         .addReg(PPC::R11)
 930         .addReg(PPC::R11)
 931         .addExpr(SubHa16));
 932       // mtlr r0
 933       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
 934
 935       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
 936       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
 937       const MCExpr *SubLo16 = PPCMCExpr::CreateLo(Sub, isDarwin, OutContext);
 938       EmitToStreamer(OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
 939         .addReg(PPC::R12)
 940         .addExpr(SubLo16).addExpr(SubLo16)
 941         .addReg(PPC::R11));
 942       // mtctr r12
 943       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
 944       // bctr
 945       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCTR));
 946
 947       OutStreamer.SwitchSection(LSPSection);
 948       OutStreamer.EmitLabel(LazyPtr);
 949       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
 950
 951       MCSymbol *DyldStubBindingHelper =
 952         OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
 953       if (isPPC64) {
 954         // .quad dyld_stub_binding_helper
 955         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
 956       } else {
 957         // .long dyld_stub_binding_helper
 958         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
 959       }
 960     }
 961     OutStreamer.AddBlankLine();
 962     return;
 963   }
 964
 965   const MCSection *StubSection =
 966     OutContext.getMachOSection("__TEXT","__symbol_stub1",
 967                                MachO::S_SYMBOL_STUBS |
 968                                MachO::S_ATTR_PURE_INSTRUCTIONS,
 969                                16, SectionKind::getText());
 970   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 971     MCSymbol *Stub = Stubs[i].first;
 972     MCSymbol *RawSym = Stubs[i].second.getPointer();
 973     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
 974     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
 975
 976     OutStreamer.SwitchSection(StubSection);
 977     EmitAlignment(4);
 978     OutStreamer.EmitLabel(Stub);
 979     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
 980
 981     // lis r11, ha16(LazyPtr)
 982     const MCExpr *LazyPtrHa16 =
 983       PPCMCExpr::CreateHa(LazyPtrExpr, isDarwin, OutContext);
 984     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LIS)
 985       .addReg(PPC::R11)
 986       .addExpr(LazyPtrHa16));
 987
 988     // ldu r12, lo16(LazyPtr)(r11)
 989     // lwzu r12, lo16(LazyPtr)(r11)
 990     const MCExpr *LazyPtrLo16 =
 991       PPCMCExpr::CreateLo(LazyPtrExpr, isDarwin, OutContext);
 992     EmitToStreamer(OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
 993       .addReg(PPC::R12)
 994       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
 995       .addReg(PPC::R11));
 996
 997     // mtctr r12
 998     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
 999     // bctr
1000     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCTR));
1001
1002     OutStreamer.SwitchSection(LSPSection);
1003     OutStreamer.EmitLabel(LazyPtr);
1004     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1005
1006     MCSymbol *DyldStubBindingHelper =
1007       OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1008     if (isPPC64) {
1009       // .quad dyld_stub_binding_helper
1010       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
1011     } else {
1012       // .long dyld_stub_binding_helper
1013       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
1014     }
1015   }
1016
1017   OutStreamer.AddBlankLine();
1018 }
1019
1020
1021 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1022   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
1023
1024   // Darwin/PPC always uses mach-o.
1025   const TargetLoweringObjectFileMachO &TLOFMacho =
1026     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1027   MachineModuleInfoMachO &MMIMacho =
1028     MMI->getObjFileInfo<MachineModuleInfoMachO>();
1029
1030   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1031   if (!Stubs.empty())
1032     EmitFunctionStubs(Stubs);
1033
1034   if (MAI->doesSupportExceptionHandling() && MMI) {
1035     // Add the (possibly multiple) personalities to the set of global values.
1036     // Only referenced functions get into the Personalities list.
1037     const std::vector<const Function*> &Personalities = MMI->getPersonalities();
1038     for (std::vector<const Function*>::const_iterator I = Personalities.begin(),
1039          E = Personalities.end(); I != E; ++I) {
1040       if (*I) {
1041         MCSymbol *NLPSym = getSymbolWithGlobalValueBase(*I, "$non_lazy_ptr");
1042         MachineModuleInfoImpl::StubValueTy &StubSym =
1043           MMIMacho.getGVStubEntry(NLPSym);
1044         StubSym = MachineModuleInfoImpl::StubValueTy(getSymbol(*I), true);
1045       }
1046     }
1047   }
1048
1049   // Output stubs for dynamically-linked functions.
1050   Stubs = MMIMacho.GetGVStubList();
1051
1052   // Output macho stubs for external and common global variables.
1053   if (!Stubs.empty()) {
1054     // Switch with ".non_lazy_symbol_pointer" directive.
1055     OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1056     EmitAlignment(isPPC64 ? 3 : 2);
1057
1058     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1059       // L_foo$stub:
1060       OutStreamer.EmitLabel(Stubs[i].first);
1061       //   .indirect_symbol _foo
1062       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1063       OutStreamer.EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1064
1065       if (MCSym.getInt())
1066         // External to current translation unit.
1067         OutStreamer.EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1068       else
1069         // Internal to current translation unit.
1070         //
1071         // When we place the LSDA into the TEXT section, the type info pointers
1072         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1073         // However, sometimes the types are local to the file. So we need to
1074         // fill in the value for the NLP in those cases.
1075         OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(),
1076                                                       OutContext),
1077                               isPPC64 ? 8 : 4/*size*/);
1078     }
1079
1080     Stubs.clear();
1081     OutStreamer.AddBlankLine();
1082   }
1083
1084   Stubs = MMIMacho.GetHiddenGVStubList();
1085   if (!Stubs.empty()) {
1086     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
1087     EmitAlignment(isPPC64 ? 3 : 2);
1088
1089     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1090       // L_foo$stub:
1091       OutStreamer.EmitLabel(Stubs[i].first);
1092       //   .long _foo
1093       OutStreamer.EmitValue(MCSymbolRefExpr::
1094                             Create(Stubs[i].second.getPointer(),
1095                                    OutContext),
1096                             isPPC64 ? 8 : 4/*size*/);
1097     }
1098
1099     Stubs.clear();
1100     OutStreamer.AddBlankLine();
1101   }
1102
1103   // Funny Darwin hack: This flag tells the linker that no global symbols
1104   // contain code that falls through to other global symbols (e.g. the obvious
1105   // implementation of multiple entry points).  If this doesn't occur, the
1106   // linker can safely perform dead code stripping.  Since LLVM never generates
1107   // code that does this, it is always safe to set.
1108   OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1109
1110   return AsmPrinter::doFinalization(M);
1111 }
1112
1113 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1114 /// for a MachineFunction to the given output stream, in a format that the
1115 /// Darwin assembler can deal with.
1116 ///
1117 static AsmPrinter *createPPCAsmPrinterPass(TargetMachine &tm,
1118                                            MCStreamer &Streamer) {
1119   const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();
1120
1121   if (Subtarget->isDarwin())
1122     return new PPCDarwinAsmPrinter(tm, Streamer);
1123   return new PPCLinuxAsmPrinter(tm, Streamer);
1124 }
1125
1126 // Force static initialization.
1127 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1128   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1129   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1130   TargetRegistry::RegisterAsmPrinter(ThePPC64LETarget, createPPCAsmPrinterPass);
1131 }