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