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.getSubtargetImpl()->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     case 'U': // Print 'u' for update form.
 279     case 'X': // Print 'x' for indexed form.
 280       {
 281         // Memory constraints should always produce an MO_Register,
 282         // so we never get an update or indexed form.  (In GCC, these
 283         // are useful in internal code gen; not so much in inline asm.)
 284         // So tolerate these but don't output anything.
 285         assert(MI->getOperand(OpNo).isReg());
 286         return false;
 287       }
 288     }
 289   }
 290
 291   assert(MI->getOperand(OpNo).isReg());
 292   O << "0(";
 293   printOperand(MI, OpNo, O);
 294   O << ")";
 295   return false;
 296 }
 297
 298
 299 /// lookUpOrCreateTOCEntry -- Given a symbol, look up whether a TOC entry
 300 /// exists for it.  If not, create one.  Then return a symbol that references
 301 /// the TOC entry.
 302 MCSymbol *PPCAsmPrinter::lookUpOrCreateTOCEntry(MCSymbol *Sym) {
 303   const DataLayout *DL = TM.getSubtargetImpl()->getDataLayout();
 304   MCSymbol *&TOCEntry = TOC[Sym];
 305
 306   // To avoid name clash check if the name already exists.
 307   while (!TOCEntry) {
 308     if (OutContext.LookupSymbol(Twine(DL->getPrivateGlobalPrefix()) +
 309                                 "C" + Twine(TOCLabelID++)) == nullptr) {
 310       TOCEntry = GetTempSymbol("C", TOCLabelID);
 311     }
 312   }
 313
 314   return TOCEntry;
 315 }
 316
 317
 318 /// EmitInstruction -- Print out a single PowerPC MI in Darwin syntax to
 319 /// the current output stream.
 320 ///
 321 void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) {
 322   MCInst TmpInst;
 323   bool isPPC64 = Subtarget.isPPC64();
 324
 325   // Lower multi-instruction pseudo operations.
 326   switch (MI->getOpcode()) {
 327   default: break;
 328   case TargetOpcode::DBG_VALUE:
 329     llvm_unreachable("Should be handled target independently");
 330   case PPC::MovePCtoLR:
 331   case PPC::MovePCtoLR8: {
 332     // Transform %LR = MovePCtoLR
 333     // Into this, where the label is the PIC base:
 334     //     bl L1$pb
 335     // L1$pb:
 336     MCSymbol *PICBase = MF->getPICBaseSymbol();
 337
 338     // Emit the 'bl'.
 339     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL)
 340       // FIXME: We would like an efficient form for this, so we don't have to do
 341       // a lot of extra uniquing.
 342       .addExpr(MCSymbolRefExpr::Create(PICBase, OutContext)));
 343
 344     // Emit the label.
 345     OutStreamer.EmitLabel(PICBase);
 346     return;
 347   }
 348   case PPC::GetGBRO: {
 349     // Get the offset from the GOT Base Register to the GOT
 350     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 351     MCSymbol *PICOffset = MF->getInfo<PPCFunctionInfo>()->getPICOffsetSymbol();
 352     TmpInst.setOpcode(PPC::LWZ);
 353     const MCExpr *Exp =
 354       MCSymbolRefExpr::Create(PICOffset, MCSymbolRefExpr::VK_None, OutContext);
 355     const MCExpr *PB =
 356       MCSymbolRefExpr::Create(MF->getPICBaseSymbol(),
 357                               MCSymbolRefExpr::VK_None,
 358                               OutContext);
 359     const MCOperand MO = TmpInst.getOperand(1);
 360     TmpInst.getOperand(1) = MCOperand::CreateExpr(MCBinaryExpr::CreateSub(Exp,
 361                                                                           PB,
 362                                                                           OutContext));
 363     TmpInst.addOperand(MO);
 364     EmitToStreamer(OutStreamer, TmpInst);
 365     return;
 366   }
 367   case PPC::UpdateGBR: {
 368     // Update the GOT Base Register to point to the GOT.  It may be possible to
 369     // merge this with the PPC::GetGBRO, doing it all in one step.
 370     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 371     TmpInst.setOpcode(PPC::ADD4);
 372     TmpInst.addOperand(TmpInst.getOperand(0));
 373     EmitToStreamer(OutStreamer, TmpInst);
 374     return;
 375   }
 376   case PPC::LWZtoc: {
 377     // Transform %X3 = LWZtoc <ga:@min1>, %X2
 378     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 379
 380     // Change the opcode to LWZ, and the global address operand to be a
 381     // reference to the GOT entry we will synthesize later.
 382     TmpInst.setOpcode(PPC::LWZ);
 383     const MachineOperand &MO = MI->getOperand(1);
 384
 385     // Map symbol -> label of TOC entry
 386     assert(MO.isGlobal() || MO.isCPI() || MO.isJTI());
 387     MCSymbol *MOSymbol = nullptr;
 388     if (MO.isGlobal())
 389       MOSymbol = getSymbol(MO.getGlobal());
 390     else if (MO.isCPI())
 391       MOSymbol = GetCPISymbol(MO.getIndex());
 392     else if (MO.isJTI())
 393       MOSymbol = GetJTISymbol(MO.getIndex());
 394
 395     MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol);
 396
 397     const MCExpr *Exp =
 398       MCSymbolRefExpr::Create(TOCEntry, MCSymbolRefExpr::VK_None,
 399                               OutContext);
 400     const MCExpr *PB =
 401       MCSymbolRefExpr::Create(OutContext.GetOrCreateSymbol(Twine(".L.TOC.")),
 402                                                            OutContext);
 403     Exp = MCBinaryExpr::CreateSub(Exp, PB, OutContext);
 404     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 405     EmitToStreamer(OutStreamer, TmpInst);
 406     return;
 407   }
 408   case PPC::LDtocJTI:
 409   case PPC::LDtocCPT:
 410   case PPC::LDtoc: {
 411     // Transform %X3 = LDtoc <ga:@min1>, %X2
 412     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 413
 414     // Change the opcode to LD, and the global address operand to be a
 415     // reference to the TOC entry we will synthesize later.
 416     TmpInst.setOpcode(PPC::LD);
 417     const MachineOperand &MO = MI->getOperand(1);
 418
 419     // Map symbol -> label of TOC entry
 420     assert(MO.isGlobal() || MO.isCPI() || MO.isJTI());
 421     MCSymbol *MOSymbol = nullptr;
 422     if (MO.isGlobal())
 423       MOSymbol = getSymbol(MO.getGlobal());
 424     else if (MO.isCPI())
 425       MOSymbol = GetCPISymbol(MO.getIndex());
 426     else if (MO.isJTI())
 427       MOSymbol = GetJTISymbol(MO.getIndex());
 428
 429     MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol);
 430
 431     const MCExpr *Exp =
 432       MCSymbolRefExpr::Create(TOCEntry, MCSymbolRefExpr::VK_PPC_TOC,
 433                               OutContext);
 434     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 435     EmitToStreamer(OutStreamer, TmpInst);
 436     return;
 437   }
 438
 439   case PPC::ADDIStocHA: {
 440     // Transform %Xd = ADDIStocHA %X2, <ga:@sym>
 441     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 442
 443     // Change the opcode to ADDIS8.  If the global address is external, has
 444     // common linkage, is a non-local function address, or is a jump table
 445     // address, then generate a TOC entry and reference that.  Otherwise
 446     // reference the symbol directly.
 447     TmpInst.setOpcode(PPC::ADDIS8);
 448     const MachineOperand &MO = MI->getOperand(2);
 449     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI()) &&
 450            "Invalid operand for ADDIStocHA!");
 451     MCSymbol *MOSymbol = nullptr;
 452     bool IsExternal = false;
 453     bool IsNonLocalFunction = false;
 454     bool IsCommon = false;
 455     bool IsAvailExt = false;
 456
 457     if (MO.isGlobal()) {
 458       const GlobalValue *GV = MO.getGlobal();
 459       MOSymbol = getSymbol(GV);
 460       IsExternal = GV->isDeclaration();
 461       IsCommon = GV->hasCommonLinkage();
 462       IsNonLocalFunction = GV->getType()->getElementType()->isFunctionTy() &&
 463         (GV->isDeclaration() || GV->isWeakForLinker());
 464       IsAvailExt = GV->hasAvailableExternallyLinkage();
 465     } else if (MO.isCPI())
 466       MOSymbol = GetCPISymbol(MO.getIndex());
 467     else if (MO.isJTI())
 468       MOSymbol = GetJTISymbol(MO.getIndex());
 469
 470     if (IsExternal || IsNonLocalFunction || IsCommon || IsAvailExt ||
 471         MO.isJTI() || TM.getCodeModel() == CodeModel::Large)
 472       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 473
 474     const MCExpr *Exp =
 475       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_HA,
 476                               OutContext);
 477     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
 478     EmitToStreamer(OutStreamer, TmpInst);
 479     return;
 480   }
 481   case PPC::LDtocL: {
 482     // Transform %Xd = LDtocL <ga:@sym>, %Xs
 483     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 484
 485     // Change the opcode to LD.  If the global address is external, has
 486     // common linkage, or is a jump table address, then reference the
 487     // associated TOC entry.  Otherwise reference the symbol directly.
 488     TmpInst.setOpcode(PPC::LD);
 489     const MachineOperand &MO = MI->getOperand(1);
 490     assert((MO.isGlobal() || MO.isJTI() || MO.isCPI()) &&
 491            "Invalid operand for LDtocL!");
 492     MCSymbol *MOSymbol = nullptr;
 493
 494     if (MO.isJTI())
 495       MOSymbol = lookUpOrCreateTOCEntry(GetJTISymbol(MO.getIndex()));
 496     else if (MO.isCPI()) {
 497       MOSymbol = GetCPISymbol(MO.getIndex());
 498       if (TM.getCodeModel() == CodeModel::Large)
 499         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 500     }
 501     else if (MO.isGlobal()) {
 502       const GlobalValue *GValue = MO.getGlobal();
 503       MOSymbol = getSymbol(GValue);
 504       if (GValue->getType()->getElementType()->isFunctionTy() ||
 505           GValue->isDeclaration() || GValue->hasCommonLinkage() ||
 506           GValue->hasAvailableExternallyLinkage() ||
 507           TM.getCodeModel() == CodeModel::Large)
 508         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 509     }
 510
 511     const MCExpr *Exp =
 512       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
 513                               OutContext);
 514     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 515     EmitToStreamer(OutStreamer, TmpInst);
 516     return;
 517   }
 518   case PPC::ADDItocL: {
 519     // Transform %Xd = ADDItocL %Xs, <ga:@sym>
 520     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 521
 522     // Change the opcode to ADDI8.  If the global address is external, then
 523     // generate a TOC entry and reference that.  Otherwise reference the
 524     // symbol directly.
 525     TmpInst.setOpcode(PPC::ADDI8);
 526     const MachineOperand &MO = MI->getOperand(2);
 527     assert((MO.isGlobal() || MO.isCPI()) && "Invalid operand for ADDItocL");
 528     MCSymbol *MOSymbol = nullptr;
 529     bool IsExternal = false;
 530     bool IsNonLocalFunction = false;
 531
 532     if (MO.isGlobal()) {
 533       const GlobalValue *GV = MO.getGlobal();
 534       MOSymbol = getSymbol(GV);
 535       IsExternal = GV->isDeclaration();
 536       IsNonLocalFunction = GV->getType()->getElementType()->isFunctionTy() &&
 537         (GV->isDeclaration() || GV->isWeakForLinker());
 538     } else if (MO.isCPI())
 539       MOSymbol = GetCPISymbol(MO.getIndex());
 540
 541     if (IsNonLocalFunction || IsExternal ||
 542         TM.getCodeModel() == CodeModel::Large)
 543       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 544
 545     const MCExpr *Exp =
 546       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC_LO,
 547                               OutContext);
 548     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
 549     EmitToStreamer(OutStreamer, TmpInst);
 550     return;
 551   }
 552   case PPC::ADDISgotTprelHA: {
 553     // Transform: %Xd = ADDISgotTprelHA %X2, <ga:@sym>
 554     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 555     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 556     const MachineOperand &MO = MI->getOperand(2);
 557     const GlobalValue *GValue = MO.getGlobal();
 558     MCSymbol *MOSymbol = getSymbol(GValue);
 559     const MCExpr *SymGotTprel =
 560       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA,
 561                               OutContext);
 562     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 563                                 .addReg(MI->getOperand(0).getReg())
 564                                 .addReg(PPC::X2)
 565                                 .addExpr(SymGotTprel));
 566     return;
 567   }
 568   case PPC::LDgotTprelL:
 569   case PPC::LDgotTprelL32: {
 570     // Transform %Xd = LDgotTprelL <ga:@sym>, %Xs
 571     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 572
 573     // Change the opcode to LD.
 574     TmpInst.setOpcode(isPPC64 ? PPC::LD : PPC::LWZ);
 575     const MachineOperand &MO = MI->getOperand(1);
 576     const GlobalValue *GValue = MO.getGlobal();
 577     MCSymbol *MOSymbol = getSymbol(GValue);
 578     const MCExpr *Exp =
 579       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO,
 580                               OutContext);
 581     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 582     EmitToStreamer(OutStreamer, TmpInst);
 583     return;
 584   }
 585
 586   case PPC::PPC32PICGOT: {
 587     MCSymbol *GOTSymbol = OutContext.GetOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
 588     MCSymbol *GOTRef = OutContext.CreateTempSymbol();
 589     MCSymbol *NextInstr = OutContext.CreateTempSymbol();
 590
 591     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL)
 592       // FIXME: We would like an efficient form for this, so we don't have to do
 593       // a lot of extra uniquing.
 594       .addExpr(MCSymbolRefExpr::Create(NextInstr, OutContext)));
 595     const MCExpr *OffsExpr =
 596       MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(GOTSymbol, OutContext),
 597                                 MCSymbolRefExpr::Create(GOTRef, OutContext),
 598         OutContext);
 599     OutStreamer.EmitLabel(GOTRef);
 600     OutStreamer.EmitValue(OffsExpr, 4);
 601     OutStreamer.EmitLabel(NextInstr);
 602     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR)
 603                                 .addReg(MI->getOperand(0).getReg()));
 604     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LWZ)
 605                                 .addReg(MI->getOperand(1).getReg())
 606                                 .addImm(0)
 607                                 .addReg(MI->getOperand(0).getReg()));
 608     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADD4)
 609                                 .addReg(MI->getOperand(0).getReg())
 610                                 .addReg(MI->getOperand(1).getReg())
 611                                 .addReg(MI->getOperand(0).getReg()));
 612     return;
 613   }
 614   case PPC::PPC32GOT: {
 615     MCSymbol *GOTSymbol = OutContext.GetOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
 616     const MCExpr *SymGotTlsL =
 617       MCSymbolRefExpr::Create(GOTSymbol, MCSymbolRefExpr::VK_PPC_LO,
 618                               OutContext);
 619     const MCExpr *SymGotTlsHA =
 620       MCSymbolRefExpr::Create(GOTSymbol, MCSymbolRefExpr::VK_PPC_HA,
 621                               OutContext);
 622     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LI)
 623                                 .addReg(MI->getOperand(0).getReg())
 624                                 .addExpr(SymGotTlsL));
 625     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
 626                                 .addReg(MI->getOperand(0).getReg())
 627                                 .addReg(MI->getOperand(0).getReg())
 628                                 .addExpr(SymGotTlsHA));
 629     return;
 630   }
 631   case PPC::ADDIStlsgdHA: {
 632     // Transform: %Xd = ADDIStlsgdHA %X2, <ga:@sym>
 633     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 634     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 635     const MachineOperand &MO = MI->getOperand(2);
 636     const GlobalValue *GValue = MO.getGlobal();
 637     MCSymbol *MOSymbol = getSymbol(GValue);
 638     const MCExpr *SymGotTlsGD =
 639       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA,
 640                               OutContext);
 641     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 642                                 .addReg(MI->getOperand(0).getReg())
 643                                 .addReg(PPC::X2)
 644                                 .addExpr(SymGotTlsGD));
 645     return;
 646   }
 647   case PPC::ADDItlsgdL:
 648     // Transform: %Xd = ADDItlsgdL %Xs, <ga:@sym>
 649     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsgd@l
 650   case PPC::ADDItlsgdL32: {
 651     // Transform: %Rd = ADDItlsgdL32 %Rs, <ga:@sym>
 652     // Into:      %Rd = ADDI %Rs, sym@got@tlsgd
 653     const MachineOperand &MO = MI->getOperand(2);
 654     const GlobalValue *GValue = MO.getGlobal();
 655     MCSymbol *MOSymbol = getSymbol(GValue);
 656     const MCExpr *SymGotTlsGD =
 657       MCSymbolRefExpr::Create(MOSymbol, Subtarget.isPPC64() ?
 658                                          MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO :
 659                                          MCSymbolRefExpr::VK_PPC_GOT_TLSGD,
 660                               OutContext);
 661     EmitToStreamer(OutStreamer,
 662                    MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDI8 : PPC::ADDI)
 663                    .addReg(MI->getOperand(0).getReg())
 664                    .addReg(MI->getOperand(1).getReg())
 665                    .addExpr(SymGotTlsGD));
 666     return;
 667   }
 668   case PPC::GETtlsADDR:
 669     // Transform: %X3 = GETtlsADDR %X3, <ga:@sym>
 670     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsgd)
 671   case PPC::GETtlsADDR32: {
 672     // Transform: %R3 = GETtlsADDR32 %R3, <ga:@sym>
 673     // Into:      BL_TLS __tls_get_addr(sym@tlsgd)@PLT
 674
 675     StringRef Name = "__tls_get_addr";
 676     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 677     MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
 678
 679     if (!Subtarget.isPPC64() && !Subtarget.isDarwin() &&
 680         TM.getRelocationModel() == Reloc::PIC_)
 681       Kind = MCSymbolRefExpr::VK_PLT;
 682     const MCSymbolRefExpr *TlsRef =
 683       MCSymbolRefExpr::Create(TlsGetAddr, Kind, OutContext);
 684     const MachineOperand &MO = MI->getOperand(2);
 685     const GlobalValue *GValue = MO.getGlobal();
 686     MCSymbol *MOSymbol = getSymbol(GValue);
 687     const MCExpr *SymVar =
 688       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSGD,
 689                               OutContext);
 690     EmitToStreamer(OutStreamer,
 691                    MCInstBuilder(Subtarget.isPPC64() ?
 692                                   PPC::BL8_NOP_TLS : PPC::BL_TLS)
 693                    .addExpr(TlsRef)
 694                    .addExpr(SymVar));
 695     return;
 696   }
 697   case PPC::ADDIStlsldHA: {
 698     // Transform: %Xd = ADDIStlsldHA %X2, <ga:@sym>
 699     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsld@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 *SymGotTlsLD =
 705       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA,
 706                               OutContext);
 707     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 708                                 .addReg(MI->getOperand(0).getReg())
 709                                 .addReg(PPC::X2)
 710                                 .addExpr(SymGotTlsLD));
 711     return;
 712   }
 713   case PPC::ADDItlsldL:
 714     // Transform: %Xd = ADDItlsldL %Xs, <ga:@sym>
 715     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsld@l
 716   case PPC::ADDItlsldL32: {
 717     // Transform: %Rd = ADDItlsldL32 %Rs, <ga:@sym>
 718     // Into:      %Rd = ADDI %Rs, sym@got@tlsld
 719     const MachineOperand &MO = MI->getOperand(2);
 720     const GlobalValue *GValue = MO.getGlobal();
 721     MCSymbol *MOSymbol = getSymbol(GValue);
 722     const MCExpr *SymGotTlsLD =
 723       MCSymbolRefExpr::Create(MOSymbol, Subtarget.isPPC64() ?
 724                                          MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO :
 725                                          MCSymbolRefExpr::VK_PPC_GOT_TLSLD,
 726                               OutContext);
 727     EmitToStreamer(OutStreamer,
 728                    MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDI8 : PPC::ADDI)
 729                    .addReg(MI->getOperand(0).getReg())
 730                    .addReg(MI->getOperand(1).getReg())
 731                    .addExpr(SymGotTlsLD));
 732     return;
 733   }
 734   case PPC::GETtlsldADDR:
 735     // Transform: %X3 = GETtlsldADDR %X3, <ga:@sym>
 736     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsld)
 737   case PPC::GETtlsldADDR32: {
 738     // Transform: %R3 = GETtlsldADDR32 %R3, <ga:@sym>
 739     // Into:      BL_TLS __tls_get_addr(sym@tlsld)@PLT
 740
 741     StringRef Name = "__tls_get_addr";
 742     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 743     MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
 744
 745     if (!Subtarget.isPPC64() && !Subtarget.isDarwin() &&
 746         TM.getRelocationModel() == Reloc::PIC_)
 747       Kind = MCSymbolRefExpr::VK_PLT;
 748
 749     const MCSymbolRefExpr *TlsRef =
 750       MCSymbolRefExpr::Create(TlsGetAddr, Kind, OutContext);
 751     const MachineOperand &MO = MI->getOperand(2);
 752     const GlobalValue *GValue = MO.getGlobal();
 753     MCSymbol *MOSymbol = getSymbol(GValue);
 754     const MCExpr *SymVar =
 755       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSLD,
 756                               OutContext);
 757     EmitToStreamer(OutStreamer,
 758                    MCInstBuilder(Subtarget.isPPC64() ?
 759                                   PPC::BL8_NOP_TLS : PPC::BL_TLS)
 760                    .addExpr(TlsRef)
 761                    .addExpr(SymVar));
 762     return;
 763   }
 764   case PPC::ADDISdtprelHA:
 765     // Transform: %Xd = ADDISdtprelHA %X3, <ga:@sym>
 766     // Into:      %Xd = ADDIS8 %X3, sym@dtprel@ha
 767   case PPC::ADDISdtprelHA32: {
 768     // Transform: %Rd = ADDISdtprelHA32 %R3, <ga:@sym>
 769     // Into:      %Rd = ADDIS %R3, sym@dtprel@ha
 770     const MachineOperand &MO = MI->getOperand(2);
 771     const GlobalValue *GValue = MO.getGlobal();
 772     MCSymbol *MOSymbol = getSymbol(GValue);
 773     const MCExpr *SymDtprel =
 774       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_HA,
 775                               OutContext);
 776     EmitToStreamer(OutStreamer,
 777                    MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDIS8 : PPC::ADDIS)
 778                    .addReg(MI->getOperand(0).getReg())
 779                    .addReg(Subtarget.isPPC64() ? PPC::X3 : PPC::R3)
 780                    .addExpr(SymDtprel));
 781     return;
 782   }
 783   case PPC::ADDIdtprelL:
 784     // Transform: %Xd = ADDIdtprelL %Xs, <ga:@sym>
 785     // Into:      %Xd = ADDI8 %Xs, sym@dtprel@l
 786   case PPC::ADDIdtprelL32: {
 787     // Transform: %Rd = ADDIdtprelL32 %Rs, <ga:@sym>
 788     // Into:      %Rd = ADDI %Rs, sym@dtprel@l
 789     const MachineOperand &MO = MI->getOperand(2);
 790     const GlobalValue *GValue = MO.getGlobal();
 791     MCSymbol *MOSymbol = getSymbol(GValue);
 792     const MCExpr *SymDtprel =
 793       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_LO,
 794                               OutContext);
 795     EmitToStreamer(OutStreamer,
 796                    MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDI8 : PPC::ADDI)
 797                    .addReg(MI->getOperand(0).getReg())
 798                    .addReg(MI->getOperand(1).getReg())
 799                    .addExpr(SymDtprel));
 800     return;
 801   }
 802   case PPC::MFOCRF:
 803   case PPC::MFOCRF8:
 804     if (!Subtarget.hasMFOCRF()) {
 805       // Transform: %R3 = MFOCRF %CR7
 806       // Into:      %R3 = MFCR   ;; cr7
 807       unsigned NewOpcode =
 808         MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
 809       OutStreamer.AddComment(PPCInstPrinter::
 810                              getRegisterName(MI->getOperand(1).getReg()));
 811       EmitToStreamer(OutStreamer, MCInstBuilder(NewOpcode)
 812                                   .addReg(MI->getOperand(0).getReg()));
 813       return;
 814     }
 815     break;
 816   case PPC::MTOCRF:
 817   case PPC::MTOCRF8:
 818     if (!Subtarget.hasMFOCRF()) {
 819       // Transform: %CR7 = MTOCRF %R3
 820       // Into:      MTCRF mask, %R3 ;; cr7
 821       unsigned NewOpcode =
 822         MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
 823       unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
 824                               ->getEncodingValue(MI->getOperand(0).getReg());
 825       OutStreamer.AddComment(PPCInstPrinter::
 826                              getRegisterName(MI->getOperand(0).getReg()));
 827       EmitToStreamer(OutStreamer, MCInstBuilder(NewOpcode)
 828                                   .addImm(Mask)
 829                                   .addReg(MI->getOperand(1).getReg()));
 830       return;
 831     }
 832     break;
 833   case PPC::LD:
 834   case PPC::STD:
 835   case PPC::LWA_32:
 836   case PPC::LWA: {
 837     // Verify alignment is legal, so we don't create relocations
 838     // that can't be supported.
 839     // FIXME:  This test is currently disabled for Darwin.  The test
 840     // suite shows a handful of test cases that fail this check for
 841     // Darwin.  Those need to be investigated before this sanity test
 842     // can be enabled for those subtargets.
 843     if (!Subtarget.isDarwin()) {
 844       unsigned OpNum = (MI->getOpcode() == PPC::STD) ? 2 : 1;
 845       const MachineOperand &MO = MI->getOperand(OpNum);
 846       if (MO.isGlobal() && MO.getGlobal()->getAlignment() < 4)
 847         llvm_unreachable("Global must be word-aligned for LD, STD, LWA!");
 848     }
 849     // Now process the instruction normally.
 850     break;
 851   }
 852   }
 853
 854   LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 855   EmitToStreamer(OutStreamer, TmpInst);
 856 }
 857
 858 void PPCLinuxAsmPrinter::EmitStartOfAsmFile(Module &M) {
 859   if (Subtarget.isELFv2ABI()) {
 860     PPCTargetStreamer *TS =
 861       static_cast<PPCTargetStreamer *>(OutStreamer.getTargetStreamer());
 862
 863     if (TS)
 864       TS->emitAbiVersion(2);
 865   }
 866
 867   if (Subtarget.isPPC64() || TM.getRelocationModel() != Reloc::PIC_)
 868     return AsmPrinter::EmitStartOfAsmFile(M);
 869
 870   // FIXME: The use of .got2 assumes large GOT model (-fPIC), which is not
 871   // optimal for some cases.  We should consider supporting small model (-fpic)
 872   // as well in the future.
 873   assert(TM.getCodeModel() != CodeModel::Small &&
 874          "Small code model PIC is currently unsupported.");
 875   OutStreamer.SwitchSection(OutContext.getELFSection(".got2",
 876          ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 877          SectionKind::getReadOnly()));
 878
 879   MCSymbol *TOCSym = OutContext.GetOrCreateSymbol(Twine(".L.TOC."));
 880   MCSymbol *CurrentPos = OutContext.CreateTempSymbol();
 881
 882   OutStreamer.EmitLabel(CurrentPos);
 883
 884   // The GOT pointer points to the middle of the GOT, in order to reference the
 885   // entire 64kB range.  0x8000 is the midpoint.
 886   const MCExpr *tocExpr =
 887     MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(CurrentPos, OutContext),
 888                             MCConstantExpr::Create(0x8000, OutContext),
 889                             OutContext);
 890
 891   OutStreamer.EmitAssignment(TOCSym, tocExpr);
 892
 893   OutStreamer.SwitchSection(getObjFileLowering().getTextSection());
 894 }
 895
 896 void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
 897   // linux/ppc32 - Normal entry label.
 898   if (!Subtarget.isPPC64() && TM.getRelocationModel() != Reloc::PIC_)
 899     return AsmPrinter::EmitFunctionEntryLabel();
 900
 901   if (!Subtarget.isPPC64()) {
 902     const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
 903         if (PPCFI->usesPICBase()) {
 904       MCSymbol *RelocSymbol = PPCFI->getPICOffsetSymbol();
 905       MCSymbol *PICBase = MF->getPICBaseSymbol();
 906       OutStreamer.EmitLabel(RelocSymbol);
 907
 908       const MCExpr *OffsExpr =
 909         MCBinaryExpr::CreateSub(
 910           MCSymbolRefExpr::Create(OutContext.GetOrCreateSymbol(Twine(".L.TOC.")),
 911                                                                OutContext),
 912                                   MCSymbolRefExpr::Create(PICBase, OutContext),
 913           OutContext);
 914       OutStreamer.EmitValue(OffsExpr, 4);
 915       OutStreamer.EmitLabel(CurrentFnSym);
 916       return;
 917     } else
 918       return AsmPrinter::EmitFunctionEntryLabel();
 919   }
 920
 921   // ELFv2 ABI - Normal entry label.
 922   if (Subtarget.isELFv2ABI())
 923     return AsmPrinter::EmitFunctionEntryLabel();
 924
 925   // Emit an official procedure descriptor.
 926   MCSectionSubPair Current = OutStreamer.getCurrentSection();
 927   const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".opd",
 928       ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 929       SectionKind::getReadOnly());
 930   OutStreamer.SwitchSection(Section);
 931   OutStreamer.EmitLabel(CurrentFnSym);
 932   OutStreamer.EmitValueToAlignment(8);
 933   MCSymbol *Symbol1 =
 934     OutContext.GetOrCreateSymbol(".L." + Twine(CurrentFnSym->getName()));
 935   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
 936   // entry point.
 937   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol1, OutContext),
 938                         8 /*size*/);
 939   MCSymbol *Symbol2 = OutContext.GetOrCreateSymbol(StringRef(".TOC."));
 940   // Generates a R_PPC64_TOC relocation for TOC base insertion.
 941   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol2,
 942                         MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
 943                         8/*size*/);
 944   // Emit a null environment pointer.
 945   OutStreamer.EmitIntValue(0, 8 /* size */);
 946   OutStreamer.SwitchSection(Current.first, Current.second);
 947
 948   MCSymbol *RealFnSym = OutContext.GetOrCreateSymbol(
 949                           ".L." + Twine(CurrentFnSym->getName()));
 950   OutStreamer.EmitLabel(RealFnSym);
 951   CurrentFnSymForSize = RealFnSym;
 952 }
 953
 954
 955 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
 956   const DataLayout *TD = TM.getSubtargetImpl()->getDataLayout();
 957
 958   bool isPPC64 = TD->getPointerSizeInBits() == 64;
 959
 960   PPCTargetStreamer &TS =
 961       static_cast<PPCTargetStreamer &>(*OutStreamer.getTargetStreamer());
 962
 963   if (!TOC.empty()) {
 964     const MCSectionELF *Section;
 965
 966     if (isPPC64)
 967       Section = OutStreamer.getContext().getELFSection(".toc",
 968         ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 969         SectionKind::getReadOnly());
 970         else
 971       Section = OutStreamer.getContext().getELFSection(".got2",
 972         ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 973         SectionKind::getReadOnly());
 974     OutStreamer.SwitchSection(Section);
 975
 976     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
 977          E = TOC.end(); I != E; ++I) {
 978       OutStreamer.EmitLabel(I->second);
 979       MCSymbol *S = OutContext.GetOrCreateSymbol(I->first->getName());
 980       if (isPPC64)
 981         TS.emitTCEntry(*S);
 982       else
 983         OutStreamer.EmitSymbolValue(S, 4);
 984     }
 985   }
 986
 987   MachineModuleInfoELF &MMIELF =
 988     MMI->getObjFileInfo<MachineModuleInfoELF>();
 989
 990   MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
 991   if (!Stubs.empty()) {
 992     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
 993     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 994       // L_foo$stub:
 995       OutStreamer.EmitLabel(Stubs[i].first);
 996       //   .long _foo
 997       OutStreamer.EmitValue(MCSymbolRefExpr::Create(Stubs[i].second.getPointer(),
 998                                                     OutContext),
 999                             isPPC64 ? 8 : 4/*size*/);
1000     }
1001
1002     Stubs.clear();
1003     OutStreamer.AddBlankLine();
1004   }
1005
1006   return AsmPrinter::doFinalization(M);
1007 }
1008
1009 /// EmitFunctionBodyStart - Emit a global entry point prefix for ELFv2.
1010 void PPCLinuxAsmPrinter::EmitFunctionBodyStart() {
1011   // In the ELFv2 ABI, in functions that use the TOC register, we need to
1012   // provide two entry points.  The ABI guarantees that when calling the
1013   // local entry point, r2 is set up by the caller to contain the TOC base
1014   // for this function, and when calling the global entry point, r12 is set
1015   // up by the caller to hold the address of the global entry point.  We
1016   // thus emit a prefix sequence along the following lines:
1017   //
1018   // func:
1019   //         # global entry point
1020   //         addis r2,r12,(.TOC.-func)@ha
1021   //         addi  r2,r2,(.TOC.-func)@l
1022   //         .localentry func, .-func
1023   //         # local entry point, followed by function body
1024   //
1025   // This ensures we have r2 set up correctly while executing the function
1026   // body, no matter which entry point is called.
1027   if (Subtarget.isELFv2ABI()
1028       // Only do all that if the function uses r2 in the first place.
1029       && !MF->getRegInfo().use_empty(PPC::X2)) {
1030
1031     MCSymbol *GlobalEntryLabel = OutContext.CreateTempSymbol();
1032     OutStreamer.EmitLabel(GlobalEntryLabel);
1033     const MCSymbolRefExpr *GlobalEntryLabelExp =
1034       MCSymbolRefExpr::Create(GlobalEntryLabel, OutContext);
1035
1036     MCSymbol *TOCSymbol = OutContext.GetOrCreateSymbol(StringRef(".TOC."));
1037     const MCExpr *TOCDeltaExpr =
1038       MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(TOCSymbol, OutContext),
1039                               GlobalEntryLabelExp, OutContext);
1040
1041     const MCExpr *TOCDeltaHi =
1042       PPCMCExpr::CreateHa(TOCDeltaExpr, false, OutContext);
1043     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
1044                                 .addReg(PPC::X2)
1045                                 .addReg(PPC::X12)
1046                                 .addExpr(TOCDeltaHi));
1047
1048     const MCExpr *TOCDeltaLo =
1049       PPCMCExpr::CreateLo(TOCDeltaExpr, false, OutContext);
1050     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI)
1051                                 .addReg(PPC::X2)
1052                                 .addReg(PPC::X2)
1053                                 .addExpr(TOCDeltaLo));
1054
1055     MCSymbol *LocalEntryLabel = OutContext.CreateTempSymbol();
1056     OutStreamer.EmitLabel(LocalEntryLabel);
1057     const MCSymbolRefExpr *LocalEntryLabelExp =
1058        MCSymbolRefExpr::Create(LocalEntryLabel, OutContext);
1059     const MCExpr *LocalOffsetExp =
1060       MCBinaryExpr::CreateSub(LocalEntryLabelExp,
1061                               GlobalEntryLabelExp, OutContext);
1062
1063     PPCTargetStreamer *TS =
1064       static_cast<PPCTargetStreamer *>(OutStreamer.getTargetStreamer());
1065
1066     if (TS)
1067       TS->emitLocalEntry(CurrentFnSym, LocalOffsetExp);
1068   }
1069 }
1070
1071 /// EmitFunctionBodyEnd - Print the traceback table before the .size
1072 /// directive.
1073 ///
1074 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
1075   // Only the 64-bit target requires a traceback table.  For now,
1076   // we only emit the word of zeroes that GDB requires to find
1077   // the end of the function, and zeroes for the eight-byte
1078   // mandatory fields.
1079   // FIXME: We should fill in the eight-byte mandatory fields as described in
1080   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
1081   // currently make use of these fields).
1082   if (Subtarget.isPPC64()) {
1083     OutStreamer.EmitIntValue(0, 4/*size*/);
1084     OutStreamer.EmitIntValue(0, 8/*size*/);
1085   }
1086 }
1087
1088 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
1089   static const char *const CPUDirectives[] = {
1090     "",
1091     "ppc",
1092     "ppc440",
1093     "ppc601",
1094     "ppc602",
1095     "ppc603",
1096     "ppc7400",
1097     "ppc750",
1098     "ppc970",
1099     "ppcA2",
1100     "ppce500mc",
1101     "ppce5500",
1102     "power3",
1103     "power4",
1104     "power5",
1105     "power5x",
1106     "power6",
1107     "power6x",
1108     "power7",
1109     "ppc64",
1110     "ppc64le"
1111   };
1112
1113   unsigned Directive = Subtarget.getDarwinDirective();
1114   if (Subtarget.hasMFOCRF() && Directive < PPC::DIR_970)
1115     Directive = PPC::DIR_970;
1116   if (Subtarget.hasAltivec() && Directive < PPC::DIR_7400)
1117     Directive = PPC::DIR_7400;
1118   if (Subtarget.isPPC64() && Directive < PPC::DIR_64)
1119     Directive = PPC::DIR_64;
1120   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
1121
1122   assert(Directive < array_lengthof(CPUDirectives) &&
1123          "CPUDirectives[] might not be up-to-date!");
1124   PPCTargetStreamer &TStreamer =
1125       *static_cast<PPCTargetStreamer *>(OutStreamer.getTargetStreamer());
1126   TStreamer.emitMachine(CPUDirectives[Directive]);
1127
1128   // Prime text sections so they are adjacent.  This reduces the likelihood a
1129   // large data or debug section causes a branch to exceed 16M limit.
1130   const TargetLoweringObjectFileMachO &TLOFMacho =
1131     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1132   OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection());
1133   if (TM.getRelocationModel() == Reloc::PIC_) {
1134     OutStreamer.SwitchSection(
1135            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
1136                                       MachO::S_SYMBOL_STUBS |
1137                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1138                                       32, SectionKind::getText()));
1139   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
1140     OutStreamer.SwitchSection(
1141            OutContext.getMachOSection("__TEXT","__symbol_stub1",
1142                                       MachO::S_SYMBOL_STUBS |
1143                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1144                                       16, SectionKind::getText()));
1145   }
1146   OutStreamer.SwitchSection(getObjFileLowering().getTextSection());
1147 }
1148
1149 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
1150   // Remove $stub suffix, add $lazy_ptr.
1151   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
1152   return Ctx.GetOrCreateSymbol(NoStub + "$lazy_ptr");
1153 }
1154
1155 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
1156   // Add $tmp suffix to $stub, yielding $stub$tmp.
1157   return Ctx.GetOrCreateSymbol(Sym->getName() + "$tmp");
1158 }
1159
1160 void PPCDarwinAsmPrinter::
1161 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
1162   bool isPPC64 =
1163       TM.getSubtargetImpl()->getDataLayout()->getPointerSizeInBits() == 64;
1164   bool isDarwin = Subtarget.isDarwin();
1165
1166   const TargetLoweringObjectFileMachO &TLOFMacho =
1167     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1168
1169   // .lazy_symbol_pointer
1170   const MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
1171
1172   // Output stubs for dynamically-linked functions
1173   if (TM.getRelocationModel() == Reloc::PIC_) {
1174     const MCSection *StubSection =
1175     OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
1176                                MachO::S_SYMBOL_STUBS |
1177                                MachO::S_ATTR_PURE_INSTRUCTIONS,
1178                                32, SectionKind::getText());
1179     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1180       OutStreamer.SwitchSection(StubSection);
1181       EmitAlignment(4);
1182
1183       MCSymbol *Stub = Stubs[i].first;
1184       MCSymbol *RawSym = Stubs[i].second.getPointer();
1185       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1186       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
1187
1188       OutStreamer.EmitLabel(Stub);
1189       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1190
1191       const MCExpr *Anon = MCSymbolRefExpr::Create(AnonSymbol, OutContext);
1192       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
1193       const MCExpr *Sub =
1194         MCBinaryExpr::CreateSub(LazyPtrExpr, Anon, OutContext);
1195
1196       // mflr r0
1197       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
1198       // bcl 20, 31, AnonSymbol
1199       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCLalways).addExpr(Anon));
1200       OutStreamer.EmitLabel(AnonSymbol);
1201       // mflr r11
1202       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
1203       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
1204       const MCExpr *SubHa16 = PPCMCExpr::CreateHa(Sub, isDarwin, OutContext);
1205       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
1206         .addReg(PPC::R11)
1207         .addReg(PPC::R11)
1208         .addExpr(SubHa16));
1209       // mtlr r0
1210       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
1211
1212       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
1213       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
1214       const MCExpr *SubLo16 = PPCMCExpr::CreateLo(Sub, isDarwin, OutContext);
1215       EmitToStreamer(OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1216         .addReg(PPC::R12)
1217         .addExpr(SubLo16).addExpr(SubLo16)
1218         .addReg(PPC::R11));
1219       // mtctr r12
1220       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1221       // bctr
1222       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCTR));
1223
1224       OutStreamer.SwitchSection(LSPSection);
1225       OutStreamer.EmitLabel(LazyPtr);
1226       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1227
1228       MCSymbol *DyldStubBindingHelper =
1229         OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1230       if (isPPC64) {
1231         // .quad dyld_stub_binding_helper
1232         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
1233       } else {
1234         // .long dyld_stub_binding_helper
1235         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
1236       }
1237     }
1238     OutStreamer.AddBlankLine();
1239     return;
1240   }
1241
1242   const MCSection *StubSection =
1243     OutContext.getMachOSection("__TEXT","__symbol_stub1",
1244                                MachO::S_SYMBOL_STUBS |
1245                                MachO::S_ATTR_PURE_INSTRUCTIONS,
1246                                16, SectionKind::getText());
1247   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1248     MCSymbol *Stub = Stubs[i].first;
1249     MCSymbol *RawSym = Stubs[i].second.getPointer();
1250     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1251     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
1252
1253     OutStreamer.SwitchSection(StubSection);
1254     EmitAlignment(4);
1255     OutStreamer.EmitLabel(Stub);
1256     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1257
1258     // lis r11, ha16(LazyPtr)
1259     const MCExpr *LazyPtrHa16 =
1260       PPCMCExpr::CreateHa(LazyPtrExpr, isDarwin, OutContext);
1261     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LIS)
1262       .addReg(PPC::R11)
1263       .addExpr(LazyPtrHa16));
1264
1265     // ldu r12, lo16(LazyPtr)(r11)
1266     // lwzu r12, lo16(LazyPtr)(r11)
1267     const MCExpr *LazyPtrLo16 =
1268       PPCMCExpr::CreateLo(LazyPtrExpr, isDarwin, OutContext);
1269     EmitToStreamer(OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1270       .addReg(PPC::R12)
1271       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
1272       .addReg(PPC::R11));
1273
1274     // mtctr r12
1275     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1276     // bctr
1277     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCTR));
1278
1279     OutStreamer.SwitchSection(LSPSection);
1280     OutStreamer.EmitLabel(LazyPtr);
1281     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1282
1283     MCSymbol *DyldStubBindingHelper =
1284       OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1285     if (isPPC64) {
1286       // .quad dyld_stub_binding_helper
1287       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
1288     } else {
1289       // .long dyld_stub_binding_helper
1290       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
1291     }
1292   }
1293
1294   OutStreamer.AddBlankLine();
1295 }
1296
1297
1298 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1299   bool isPPC64 =
1300       TM.getSubtargetImpl()->getDataLayout()->getPointerSizeInBits() == 64;
1301
1302   // Darwin/PPC always uses mach-o.
1303   const TargetLoweringObjectFileMachO &TLOFMacho =
1304     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1305   MachineModuleInfoMachO &MMIMacho =
1306     MMI->getObjFileInfo<MachineModuleInfoMachO>();
1307
1308   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1309   if (!Stubs.empty())
1310     EmitFunctionStubs(Stubs);
1311
1312   if (MAI->doesSupportExceptionHandling() && MMI) {
1313     // Add the (possibly multiple) personalities to the set of global values.
1314     // Only referenced functions get into the Personalities list.
1315     const std::vector<const Function*> &Personalities = MMI->getPersonalities();
1316     for (std::vector<const Function*>::const_iterator I = Personalities.begin(),
1317          E = Personalities.end(); I != E; ++I) {
1318       if (*I) {
1319         MCSymbol *NLPSym = getSymbolWithGlobalValueBase(*I, "$non_lazy_ptr");
1320         MachineModuleInfoImpl::StubValueTy &StubSym =
1321           MMIMacho.getGVStubEntry(NLPSym);
1322         StubSym = MachineModuleInfoImpl::StubValueTy(getSymbol(*I), true);
1323       }
1324     }
1325   }
1326
1327   // Output stubs for dynamically-linked functions.
1328   Stubs = MMIMacho.GetGVStubList();
1329
1330   // Output macho stubs for external and common global variables.
1331   if (!Stubs.empty()) {
1332     // Switch with ".non_lazy_symbol_pointer" directive.
1333     OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1334     EmitAlignment(isPPC64 ? 3 : 2);
1335
1336     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1337       // L_foo$stub:
1338       OutStreamer.EmitLabel(Stubs[i].first);
1339       //   .indirect_symbol _foo
1340       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1341       OutStreamer.EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1342
1343       if (MCSym.getInt())
1344         // External to current translation unit.
1345         OutStreamer.EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1346       else
1347         // Internal to current translation unit.
1348         //
1349         // When we place the LSDA into the TEXT section, the type info pointers
1350         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1351         // However, sometimes the types are local to the file. So we need to
1352         // fill in the value for the NLP in those cases.
1353         OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(),
1354                                                       OutContext),
1355                               isPPC64 ? 8 : 4/*size*/);
1356     }
1357
1358     Stubs.clear();
1359     OutStreamer.AddBlankLine();
1360   }
1361
1362   Stubs = MMIMacho.GetHiddenGVStubList();
1363   if (!Stubs.empty()) {
1364     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
1365     EmitAlignment(isPPC64 ? 3 : 2);
1366
1367     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1368       // L_foo$stub:
1369       OutStreamer.EmitLabel(Stubs[i].first);
1370       //   .long _foo
1371       OutStreamer.EmitValue(MCSymbolRefExpr::
1372                             Create(Stubs[i].second.getPointer(),
1373                                    OutContext),
1374                             isPPC64 ? 8 : 4/*size*/);
1375     }
1376
1377     Stubs.clear();
1378     OutStreamer.AddBlankLine();
1379   }
1380
1381   // Funny Darwin hack: This flag tells the linker that no global symbols
1382   // contain code that falls through to other global symbols (e.g. the obvious
1383   // implementation of multiple entry points).  If this doesn't occur, the
1384   // linker can safely perform dead code stripping.  Since LLVM never generates
1385   // code that does this, it is always safe to set.
1386   OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1387
1388   return AsmPrinter::doFinalization(M);
1389 }
1390
1391 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1392 /// for a MachineFunction to the given output stream, in a format that the
1393 /// Darwin assembler can deal with.
1394 ///
1395 static AsmPrinter *createPPCAsmPrinterPass(TargetMachine &tm,
1396                                            MCStreamer &Streamer) {
1397   const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();
1398
1399   if (Subtarget->isDarwin())
1400     return new PPCDarwinAsmPrinter(tm, Streamer);
1401   return new PPCLinuxAsmPrinter(tm, Streamer);
1402 }
1403
1404 // Force static initialization.
1405 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1406   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1407   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1408   TargetRegistry::RegisterAsmPrinter(ThePPC64LETarget, createPPCAsmPrinterPass);
1409 }