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::PPC32PICGOT: {
 577     MCSymbol *GOTSymbol = OutContext.GetOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
 578     MCSymbol *GOTRef = OutContext.CreateTempSymbol();
 579     MCSymbol *NextInstr = OutContext.CreateTempSymbol();
 580
 581     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL)
 582       // FIXME: We would like an efficient form for this, so we don't have to do
 583       // a lot of extra uniquing.
 584       .addExpr(MCSymbolRefExpr::Create(NextInstr, OutContext)));
 585     const MCExpr *OffsExpr =
 586       MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(GOTSymbol, OutContext),
 587                                 MCSymbolRefExpr::Create(GOTRef, OutContext),
 588         OutContext);
 589     OutStreamer.EmitLabel(GOTRef);
 590     OutStreamer.EmitValue(OffsExpr, 4);
 591     OutStreamer.EmitLabel(NextInstr);
 592     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR)
 593                                 .addReg(MI->getOperand(0).getReg()));
 594     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LWZ)
 595                                 .addReg(MI->getOperand(1).getReg())
 596                                 .addImm(0)
 597                                 .addReg(MI->getOperand(0).getReg()));
 598     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADD4)
 599                                 .addReg(MI->getOperand(0).getReg())
 600                                 .addReg(MI->getOperand(1).getReg())
 601                                 .addReg(MI->getOperand(0).getReg()));
 602     return;
 603   }
 604   case PPC::PPC32GOT: {
 605     MCSymbol *GOTSymbol = OutContext.GetOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
 606     const MCExpr *SymGotTlsL =
 607       MCSymbolRefExpr::Create(GOTSymbol, MCSymbolRefExpr::VK_PPC_LO,
 608                               OutContext);
 609     const MCExpr *SymGotTlsHA =
 610       MCSymbolRefExpr::Create(GOTSymbol, MCSymbolRefExpr::VK_PPC_HA,
 611                               OutContext);
 612     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LI)
 613                                 .addReg(MI->getOperand(0).getReg())
 614                                 .addExpr(SymGotTlsL));
 615     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
 616                                 .addReg(MI->getOperand(0).getReg())
 617                                 .addReg(MI->getOperand(0).getReg())
 618                                 .addExpr(SymGotTlsHA));
 619     return;
 620   }
 621   case PPC::ADDIStlsgdHA: {
 622     // Transform: %Xd = ADDIStlsgdHA %X2, <ga:@sym>
 623     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 624     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 625     const MachineOperand &MO = MI->getOperand(2);
 626     const GlobalValue *GValue = MO.getGlobal();
 627     MCSymbol *MOSymbol = getSymbol(GValue);
 628     const MCExpr *SymGotTlsGD =
 629       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA,
 630                               OutContext);
 631     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 632                                 .addReg(MI->getOperand(0).getReg())
 633                                 .addReg(PPC::X2)
 634                                 .addExpr(SymGotTlsGD));
 635     return;
 636   }
 637   case PPC::ADDItlsgdL:
 638     // Transform: %Xd = ADDItlsgdL %Xs, <ga:@sym>
 639     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsgd@l
 640   case PPC::ADDItlsgdL32: {
 641     // Transform: %Rd = ADDItlsgdL32 %Rs, <ga:@sym>
 642     // Into:      %Rd = ADDI %Rs, sym@got@tlsgd
 643     const MachineOperand &MO = MI->getOperand(2);
 644     const GlobalValue *GValue = MO.getGlobal();
 645     MCSymbol *MOSymbol = getSymbol(GValue);
 646     const MCExpr *SymGotTlsGD =
 647       MCSymbolRefExpr::Create(MOSymbol, Subtarget.isPPC64() ?
 648                                          MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO :
 649                                          MCSymbolRefExpr::VK_PPC_GOT_TLSGD,
 650                               OutContext);
 651     EmitToStreamer(OutStreamer,
 652                    MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDI8 : PPC::ADDI)
 653                    .addReg(MI->getOperand(0).getReg())
 654                    .addReg(MI->getOperand(1).getReg())
 655                    .addExpr(SymGotTlsGD));
 656     return;
 657   }
 658   case PPC::GETtlsADDR:
 659     // Transform: %X3 = GETtlsADDR %X3, <ga:@sym>
 660     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsgd)
 661   case PPC::GETtlsADDR32: {
 662     // Transform: %R3 = GETtlsADDR32 %R3, <ga:@sym>
 663     // Into:      BL_TLS __tls_get_addr(sym@tlsgd)@PLT
 664
 665     StringRef Name = "__tls_get_addr";
 666     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 667     MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
 668
 669     if (!Subtarget.isPPC64() && !Subtarget.isDarwin() &&
 670         TM.getRelocationModel() == Reloc::PIC_)
 671       Kind = MCSymbolRefExpr::VK_PLT;
 672     const MCSymbolRefExpr *TlsRef =
 673       MCSymbolRefExpr::Create(TlsGetAddr, Kind, OutContext);
 674     const MachineOperand &MO = MI->getOperand(2);
 675     const GlobalValue *GValue = MO.getGlobal();
 676     MCSymbol *MOSymbol = getSymbol(GValue);
 677     const MCExpr *SymVar =
 678       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSGD,
 679                               OutContext);
 680     EmitToStreamer(OutStreamer,
 681                    MCInstBuilder(Subtarget.isPPC64() ?
 682                                   PPC::BL8_NOP_TLS : PPC::BL_TLS)
 683                    .addExpr(TlsRef)
 684                    .addExpr(SymVar));
 685     return;
 686   }
 687   case PPC::ADDIStlsldHA: {
 688     // Transform: %Xd = ADDIStlsldHA %X2, <ga:@sym>
 689     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsld@ha
 690     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 691     const MachineOperand &MO = MI->getOperand(2);
 692     const GlobalValue *GValue = MO.getGlobal();
 693     MCSymbol *MOSymbol = getSymbol(GValue);
 694     const MCExpr *SymGotTlsLD =
 695       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA,
 696                               OutContext);
 697     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)
 698                                 .addReg(MI->getOperand(0).getReg())
 699                                 .addReg(PPC::X2)
 700                                 .addExpr(SymGotTlsLD));
 701     return;
 702   }
 703   case PPC::ADDItlsldL:
 704     // Transform: %Xd = ADDItlsldL %Xs, <ga:@sym>
 705     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsld@l
 706   case PPC::ADDItlsldL32: {
 707     // Transform: %Rd = ADDItlsldL32 %Rs, <ga:@sym>
 708     // Into:      %Rd = ADDI %Rs, sym@got@tlsld
 709     const MachineOperand &MO = MI->getOperand(2);
 710     const GlobalValue *GValue = MO.getGlobal();
 711     MCSymbol *MOSymbol = getSymbol(GValue);
 712     const MCExpr *SymGotTlsLD =
 713       MCSymbolRefExpr::Create(MOSymbol, Subtarget.isPPC64() ?
 714                                          MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO :
 715                                          MCSymbolRefExpr::VK_PPC_GOT_TLSLD,
 716                               OutContext);
 717     EmitToStreamer(OutStreamer,
 718                    MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDI8 : PPC::ADDI)
 719                    .addReg(MI->getOperand(0).getReg())
 720                    .addReg(MI->getOperand(1).getReg())
 721                    .addExpr(SymGotTlsLD));
 722     return;
 723   }
 724   case PPC::GETtlsldADDR:
 725     // Transform: %X3 = GETtlsldADDR %X3, <ga:@sym>
 726     // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsld)
 727   case PPC::GETtlsldADDR32: {
 728     // Transform: %R3 = GETtlsldADDR32 %R3, <ga:@sym>
 729     // Into:      BL_TLS __tls_get_addr(sym@tlsld)@PLT
 730
 731     StringRef Name = "__tls_get_addr";
 732     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 733     MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
 734
 735     if (!Subtarget.isPPC64() && !Subtarget.isDarwin() &&
 736         TM.getRelocationModel() == Reloc::PIC_)
 737       Kind = MCSymbolRefExpr::VK_PLT;
 738
 739     const MCSymbolRefExpr *TlsRef =
 740       MCSymbolRefExpr::Create(TlsGetAddr, Kind, OutContext);
 741     const MachineOperand &MO = MI->getOperand(2);
 742     const GlobalValue *GValue = MO.getGlobal();
 743     MCSymbol *MOSymbol = getSymbol(GValue);
 744     const MCExpr *SymVar =
 745       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSLD,
 746                               OutContext);
 747     EmitToStreamer(OutStreamer,
 748                    MCInstBuilder(Subtarget.isPPC64() ?
 749                                   PPC::BL8_NOP_TLS : PPC::BL_TLS)
 750                    .addExpr(TlsRef)
 751                    .addExpr(SymVar));
 752     return;
 753   }
 754   case PPC::ADDISdtprelHA:
 755     // Transform: %Xd = ADDISdtprelHA %X3, <ga:@sym>
 756     // Into:      %Xd = ADDIS8 %X3, sym@dtprel@ha
 757   case PPC::ADDISdtprelHA32: {
 758     // Transform: %Rd = ADDISdtprelHA32 %R3, <ga:@sym>
 759     // Into:      %Rd = ADDIS %R3, sym@dtprel@ha
 760     const MachineOperand &MO = MI->getOperand(2);
 761     const GlobalValue *GValue = MO.getGlobal();
 762     MCSymbol *MOSymbol = getSymbol(GValue);
 763     const MCExpr *SymDtprel =
 764       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_HA,
 765                               OutContext);
 766     EmitToStreamer(OutStreamer,
 767                    MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDIS8 : PPC::ADDIS)
 768                    .addReg(MI->getOperand(0).getReg())
 769                    .addReg(Subtarget.isPPC64() ? PPC::X3 : PPC::R3)
 770                    .addExpr(SymDtprel));
 771     return;
 772   }
 773   case PPC::ADDIdtprelL:
 774     // Transform: %Xd = ADDIdtprelL %Xs, <ga:@sym>
 775     // Into:      %Xd = ADDI8 %Xs, sym@dtprel@l
 776   case PPC::ADDIdtprelL32: {
 777     // Transform: %Rd = ADDIdtprelL32 %Rs, <ga:@sym>
 778     // Into:      %Rd = ADDI %Rs, sym@dtprel@l
 779     const MachineOperand &MO = MI->getOperand(2);
 780     const GlobalValue *GValue = MO.getGlobal();
 781     MCSymbol *MOSymbol = getSymbol(GValue);
 782     const MCExpr *SymDtprel =
 783       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_LO,
 784                               OutContext);
 785     EmitToStreamer(OutStreamer,
 786                    MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDI8 : PPC::ADDI)
 787                    .addReg(MI->getOperand(0).getReg())
 788                    .addReg(MI->getOperand(1).getReg())
 789                    .addExpr(SymDtprel));
 790     return;
 791   }
 792   case PPC::MFOCRF:
 793   case PPC::MFOCRF8:
 794     if (!Subtarget.hasMFOCRF()) {
 795       // Transform: %R3 = MFOCRF %CR7
 796       // Into:      %R3 = MFCR   ;; cr7
 797       unsigned NewOpcode =
 798         MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
 799       OutStreamer.AddComment(PPCInstPrinter::
 800                              getRegisterName(MI->getOperand(1).getReg()));
 801       EmitToStreamer(OutStreamer, MCInstBuilder(NewOpcode)
 802                                   .addReg(MI->getOperand(0).getReg()));
 803       return;
 804     }
 805     break;
 806   case PPC::MTOCRF:
 807   case PPC::MTOCRF8:
 808     if (!Subtarget.hasMFOCRF()) {
 809       // Transform: %CR7 = MTOCRF %R3
 810       // Into:      MTCRF mask, %R3 ;; cr7
 811       unsigned NewOpcode =
 812         MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
 813       unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
 814                               ->getEncodingValue(MI->getOperand(0).getReg());
 815       OutStreamer.AddComment(PPCInstPrinter::
 816                              getRegisterName(MI->getOperand(0).getReg()));
 817       EmitToStreamer(OutStreamer, MCInstBuilder(NewOpcode)
 818                                   .addImm(Mask)
 819                                   .addReg(MI->getOperand(1).getReg()));
 820       return;
 821     }
 822     break;
 823   case PPC::LD:
 824   case PPC::STD:
 825   case PPC::LWA_32:
 826   case PPC::LWA: {
 827     // Verify alignment is legal, so we don't create relocations
 828     // that can't be supported.
 829     // FIXME:  This test is currently disabled for Darwin.  The test
 830     // suite shows a handful of test cases that fail this check for
 831     // Darwin.  Those need to be investigated before this sanity test
 832     // can be enabled for those subtargets.
 833     if (!Subtarget.isDarwin()) {
 834       unsigned OpNum = (MI->getOpcode() == PPC::STD) ? 2 : 1;
 835       const MachineOperand &MO = MI->getOperand(OpNum);
 836       if (MO.isGlobal() && MO.getGlobal()->getAlignment() < 4)
 837         llvm_unreachable("Global must be word-aligned for LD, STD, LWA!");
 838     }
 839     // Now process the instruction normally.
 840     break;
 841   }
 842   }
 843
 844   LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 845   EmitToStreamer(OutStreamer, TmpInst);
 846 }
 847
 848 void PPCLinuxAsmPrinter::EmitStartOfAsmFile(Module &M) {
 849   if (Subtarget.isELFv2ABI()) {
 850     PPCTargetStreamer *TS =
 851       static_cast<PPCTargetStreamer *>(OutStreamer.getTargetStreamer());
 852
 853     if (TS)
 854       TS->emitAbiVersion(2);
 855   }
 856
 857   if (Subtarget.isPPC64() || TM.getRelocationModel() != Reloc::PIC_)
 858     return AsmPrinter::EmitStartOfAsmFile(M);
 859
 860   // FIXME: The use of .got2 assumes large GOT model (-fPIC), which is not
 861   // optimal for some cases.  We should consider supporting small model (-fpic)
 862   // as well in the future.
 863   assert(TM.getCodeModel() != CodeModel::Small &&
 864          "Small code model PIC is currently unsupported.");
 865   OutStreamer.SwitchSection(OutContext.getELFSection(".got2",
 866          ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 867          SectionKind::getReadOnly()));
 868
 869   MCSymbol *TOCSym = OutContext.GetOrCreateSymbol(Twine(".L.TOC."));
 870   MCSymbol *CurrentPos = OutContext.CreateTempSymbol();
 871
 872   OutStreamer.EmitLabel(CurrentPos);
 873
 874   // The GOT pointer points to the middle of the GOT, in order to reference the
 875   // entire 64kB range.  0x8000 is the midpoint.
 876   const MCExpr *tocExpr =
 877     MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(CurrentPos, OutContext),
 878                             MCConstantExpr::Create(0x8000, OutContext),
 879                             OutContext);
 880
 881   OutStreamer.EmitAssignment(TOCSym, tocExpr);
 882
 883   OutStreamer.SwitchSection(getObjFileLowering().getTextSection());
 884 }
 885
 886 void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
 887   // linux/ppc32 - Normal entry label.
 888   if (!Subtarget.isPPC64() && TM.getRelocationModel() != Reloc::PIC_)
 889     return AsmPrinter::EmitFunctionEntryLabel();
 890
 891   if (!Subtarget.isPPC64()) {
 892     const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
 893         if (PPCFI->usesPICBase()) {
 894       MCSymbol *RelocSymbol = PPCFI->getPICOffsetSymbol();
 895       MCSymbol *PICBase = MF->getPICBaseSymbol();
 896       OutStreamer.EmitLabel(RelocSymbol);
 897
 898       const MCExpr *OffsExpr =
 899         MCBinaryExpr::CreateSub(
 900           MCSymbolRefExpr::Create(OutContext.GetOrCreateSymbol(Twine(".L.TOC.")),
 901                                                                OutContext),
 902                                   MCSymbolRefExpr::Create(PICBase, OutContext),
 903           OutContext);
 904       OutStreamer.EmitValue(OffsExpr, 4);
 905       OutStreamer.EmitLabel(CurrentFnSym);
 906       return;
 907     } else
 908       return AsmPrinter::EmitFunctionEntryLabel();
 909   }
 910
 911   // ELFv2 ABI - Normal entry label.
 912   if (Subtarget.isELFv2ABI())
 913     return AsmPrinter::EmitFunctionEntryLabel();
 914
 915   // Emit an official procedure descriptor.
 916   MCSectionSubPair Current = OutStreamer.getCurrentSection();
 917   const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".opd",
 918       ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 919       SectionKind::getReadOnly());
 920   OutStreamer.SwitchSection(Section);
 921   OutStreamer.EmitLabel(CurrentFnSym);
 922   OutStreamer.EmitValueToAlignment(8);
 923   MCSymbol *Symbol1 =
 924     OutContext.GetOrCreateSymbol(".L." + Twine(CurrentFnSym->getName()));
 925   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
 926   // entry point.
 927   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol1, OutContext),
 928                         8 /*size*/);
 929   MCSymbol *Symbol2 = OutContext.GetOrCreateSymbol(StringRef(".TOC."));
 930   // Generates a R_PPC64_TOC relocation for TOC base insertion.
 931   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol2,
 932                         MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
 933                         8/*size*/);
 934   // Emit a null environment pointer.
 935   OutStreamer.EmitIntValue(0, 8 /* size */);
 936   OutStreamer.SwitchSection(Current.first, Current.second);
 937
 938   MCSymbol *RealFnSym = OutContext.GetOrCreateSymbol(
 939                           ".L." + Twine(CurrentFnSym->getName()));
 940   OutStreamer.EmitLabel(RealFnSym);
 941   CurrentFnSymForSize = RealFnSym;
 942 }
 943
 944
 945 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
 946   const DataLayout *TD = TM.getDataLayout();
 947
 948   bool isPPC64 = TD->getPointerSizeInBits() == 64;
 949
 950   PPCTargetStreamer &TS =
 951       static_cast<PPCTargetStreamer &>(*OutStreamer.getTargetStreamer());
 952
 953   if (!TOC.empty()) {
 954     const MCSectionELF *Section;
 955
 956     if (isPPC64)
 957       Section = OutStreamer.getContext().getELFSection(".toc",
 958         ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 959         SectionKind::getReadOnly());
 960         else
 961       Section = OutStreamer.getContext().getELFSection(".got2",
 962         ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 963         SectionKind::getReadOnly());
 964     OutStreamer.SwitchSection(Section);
 965
 966     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
 967          E = TOC.end(); I != E; ++I) {
 968       OutStreamer.EmitLabel(I->second);
 969       MCSymbol *S = OutContext.GetOrCreateSymbol(I->first->getName());
 970       if (isPPC64)
 971         TS.emitTCEntry(*S);
 972       else
 973         OutStreamer.EmitSymbolValue(S, 4);
 974     }
 975   }
 976
 977   MachineModuleInfoELF &MMIELF =
 978     MMI->getObjFileInfo<MachineModuleInfoELF>();
 979
 980   MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
 981   if (!Stubs.empty()) {
 982     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
 983     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 984       // L_foo$stub:
 985       OutStreamer.EmitLabel(Stubs[i].first);
 986       //   .long _foo
 987       OutStreamer.EmitValue(MCSymbolRefExpr::Create(Stubs[i].second.getPointer(),
 988                                                     OutContext),
 989                             isPPC64 ? 8 : 4/*size*/);
 990     }
 991
 992     Stubs.clear();
 993     OutStreamer.AddBlankLine();
 994   }
 995
 996   return AsmPrinter::doFinalization(M);
 997 }
 998
 999 /// EmitFunctionBodyStart - Emit a global entry point prefix for ELFv2.
1000 void PPCLinuxAsmPrinter::EmitFunctionBodyStart() {
1001   // In the ELFv2 ABI, in functions that use the TOC register, we need to
1002   // provide two entry points.  The ABI guarantees that when calling the
1003   // local entry point, r2 is set up by the caller to contain the TOC base
1004   // for this function, and when calling the global entry point, r12 is set
1005   // up by the caller to hold the address of the global entry point.  We
1006   // thus emit a prefix sequence along the following lines:
1007   //
1008   // func:
1009   //         # global entry point
1010   //         addis r2,r12,(.TOC.-func)@ha
1011   //         addi  r2,r2,(.TOC.-func)@l
1012   //         .localentry func, .-func
1013   //         # local entry point, followed by function body
1014   //
1015   // This ensures we have r2 set up correctly while executing the function
1016   // body, no matter which entry point is called.
1017   if (Subtarget.isELFv2ABI()
1018       // Only do all that if the function uses r2 in the first place.
1019       && !MF->getRegInfo().use_empty(PPC::X2)) {
1020
1021     MCSymbol *GlobalEntryLabel = OutContext.CreateTempSymbol();
1022     OutStreamer.EmitLabel(GlobalEntryLabel);
1023     const MCSymbolRefExpr *GlobalEntryLabelExp =
1024       MCSymbolRefExpr::Create(GlobalEntryLabel, OutContext);
1025
1026     MCSymbol *TOCSymbol = OutContext.GetOrCreateSymbol(StringRef(".TOC."));
1027     const MCExpr *TOCDeltaExpr =
1028       MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(TOCSymbol, OutContext),
1029                               GlobalEntryLabelExp, OutContext);
1030
1031     const MCExpr *TOCDeltaHi =
1032       PPCMCExpr::CreateHa(TOCDeltaExpr, false, OutContext);
1033     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
1034                                 .addReg(PPC::X2)
1035                                 .addReg(PPC::X12)
1036                                 .addExpr(TOCDeltaHi));
1037
1038     const MCExpr *TOCDeltaLo =
1039       PPCMCExpr::CreateLo(TOCDeltaExpr, false, OutContext);
1040     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI)
1041                                 .addReg(PPC::X2)
1042                                 .addReg(PPC::X2)
1043                                 .addExpr(TOCDeltaLo));
1044
1045     MCSymbol *LocalEntryLabel = OutContext.CreateTempSymbol();
1046     OutStreamer.EmitLabel(LocalEntryLabel);
1047     const MCSymbolRefExpr *LocalEntryLabelExp =
1048        MCSymbolRefExpr::Create(LocalEntryLabel, OutContext);
1049     const MCExpr *LocalOffsetExp =
1050       MCBinaryExpr::CreateSub(LocalEntryLabelExp,
1051                               GlobalEntryLabelExp, OutContext);
1052
1053     PPCTargetStreamer *TS =
1054       static_cast<PPCTargetStreamer *>(OutStreamer.getTargetStreamer());
1055
1056     if (TS)
1057       TS->emitLocalEntry(CurrentFnSym, LocalOffsetExp);
1058   }
1059 }
1060
1061 /// EmitFunctionBodyEnd - Print the traceback table before the .size
1062 /// directive.
1063 ///
1064 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
1065   // Only the 64-bit target requires a traceback table.  For now,
1066   // we only emit the word of zeroes that GDB requires to find
1067   // the end of the function, and zeroes for the eight-byte
1068   // mandatory fields.
1069   // FIXME: We should fill in the eight-byte mandatory fields as described in
1070   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
1071   // currently make use of these fields).
1072   if (Subtarget.isPPC64()) {
1073     OutStreamer.EmitIntValue(0, 4/*size*/);
1074     OutStreamer.EmitIntValue(0, 8/*size*/);
1075   }
1076 }
1077
1078 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
1079   static const char *const CPUDirectives[] = {
1080     "",
1081     "ppc",
1082     "ppc440",
1083     "ppc601",
1084     "ppc602",
1085     "ppc603",
1086     "ppc7400",
1087     "ppc750",
1088     "ppc970",
1089     "ppcA2",
1090     "ppce500mc",
1091     "ppce5500",
1092     "power3",
1093     "power4",
1094     "power5",
1095     "power5x",
1096     "power6",
1097     "power6x",
1098     "power7",
1099     "ppc64",
1100     "ppc64le"
1101   };
1102
1103   unsigned Directive = Subtarget.getDarwinDirective();
1104   if (Subtarget.hasMFOCRF() && Directive < PPC::DIR_970)
1105     Directive = PPC::DIR_970;
1106   if (Subtarget.hasAltivec() && Directive < PPC::DIR_7400)
1107     Directive = PPC::DIR_7400;
1108   if (Subtarget.isPPC64() && Directive < PPC::DIR_64)
1109     Directive = PPC::DIR_64;
1110   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
1111
1112   assert(Directive < array_lengthof(CPUDirectives) &&
1113          "CPUDirectives[] might not be up-to-date!");
1114   PPCTargetStreamer &TStreamer =
1115       *static_cast<PPCTargetStreamer *>(OutStreamer.getTargetStreamer());
1116   TStreamer.emitMachine(CPUDirectives[Directive]);
1117
1118   // Prime text sections so they are adjacent.  This reduces the likelihood a
1119   // large data or debug section causes a branch to exceed 16M limit.
1120   const TargetLoweringObjectFileMachO &TLOFMacho =
1121     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1122   OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection());
1123   if (TM.getRelocationModel() == Reloc::PIC_) {
1124     OutStreamer.SwitchSection(
1125            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
1126                                       MachO::S_SYMBOL_STUBS |
1127                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1128                                       32, SectionKind::getText()));
1129   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
1130     OutStreamer.SwitchSection(
1131            OutContext.getMachOSection("__TEXT","__symbol_stub1",
1132                                       MachO::S_SYMBOL_STUBS |
1133                                       MachO::S_ATTR_PURE_INSTRUCTIONS,
1134                                       16, SectionKind::getText()));
1135   }
1136   OutStreamer.SwitchSection(getObjFileLowering().getTextSection());
1137 }
1138
1139 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
1140   // Remove $stub suffix, add $lazy_ptr.
1141   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
1142   return Ctx.GetOrCreateSymbol(NoStub + "$lazy_ptr");
1143 }
1144
1145 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
1146   // Add $tmp suffix to $stub, yielding $stub$tmp.
1147   return Ctx.GetOrCreateSymbol(Sym->getName() + "$tmp");
1148 }
1149
1150 void PPCDarwinAsmPrinter::
1151 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
1152   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
1153   bool isDarwin = Subtarget.isDarwin();
1154
1155   const TargetLoweringObjectFileMachO &TLOFMacho =
1156     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1157
1158   // .lazy_symbol_pointer
1159   const MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
1160
1161   // Output stubs for dynamically-linked functions
1162   if (TM.getRelocationModel() == Reloc::PIC_) {
1163     const MCSection *StubSection =
1164     OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
1165                                MachO::S_SYMBOL_STUBS |
1166                                MachO::S_ATTR_PURE_INSTRUCTIONS,
1167                                32, SectionKind::getText());
1168     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1169       OutStreamer.SwitchSection(StubSection);
1170       EmitAlignment(4);
1171
1172       MCSymbol *Stub = Stubs[i].first;
1173       MCSymbol *RawSym = Stubs[i].second.getPointer();
1174       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1175       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
1176
1177       OutStreamer.EmitLabel(Stub);
1178       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1179
1180       const MCExpr *Anon = MCSymbolRefExpr::Create(AnonSymbol, OutContext);
1181       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
1182       const MCExpr *Sub =
1183         MCBinaryExpr::CreateSub(LazyPtrExpr, Anon, OutContext);
1184
1185       // mflr r0
1186       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
1187       // bcl 20, 31, AnonSymbol
1188       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCLalways).addExpr(Anon));
1189       OutStreamer.EmitLabel(AnonSymbol);
1190       // mflr r11
1191       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
1192       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
1193       const MCExpr *SubHa16 = PPCMCExpr::CreateHa(Sub, isDarwin, OutContext);
1194       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS)
1195         .addReg(PPC::R11)
1196         .addReg(PPC::R11)
1197         .addExpr(SubHa16));
1198       // mtlr r0
1199       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
1200
1201       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
1202       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
1203       const MCExpr *SubLo16 = PPCMCExpr::CreateLo(Sub, isDarwin, OutContext);
1204       EmitToStreamer(OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1205         .addReg(PPC::R12)
1206         .addExpr(SubLo16).addExpr(SubLo16)
1207         .addReg(PPC::R11));
1208       // mtctr r12
1209       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1210       // bctr
1211       EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCTR));
1212
1213       OutStreamer.SwitchSection(LSPSection);
1214       OutStreamer.EmitLabel(LazyPtr);
1215       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1216
1217       MCSymbol *DyldStubBindingHelper =
1218         OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1219       if (isPPC64) {
1220         // .quad dyld_stub_binding_helper
1221         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
1222       } else {
1223         // .long dyld_stub_binding_helper
1224         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
1225       }
1226     }
1227     OutStreamer.AddBlankLine();
1228     return;
1229   }
1230
1231   const MCSection *StubSection =
1232     OutContext.getMachOSection("__TEXT","__symbol_stub1",
1233                                MachO::S_SYMBOL_STUBS |
1234                                MachO::S_ATTR_PURE_INSTRUCTIONS,
1235                                16, SectionKind::getText());
1236   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1237     MCSymbol *Stub = Stubs[i].first;
1238     MCSymbol *RawSym = Stubs[i].second.getPointer();
1239     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
1240     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
1241
1242     OutStreamer.SwitchSection(StubSection);
1243     EmitAlignment(4);
1244     OutStreamer.EmitLabel(Stub);
1245     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1246
1247     // lis r11, ha16(LazyPtr)
1248     const MCExpr *LazyPtrHa16 =
1249       PPCMCExpr::CreateHa(LazyPtrExpr, isDarwin, OutContext);
1250     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LIS)
1251       .addReg(PPC::R11)
1252       .addExpr(LazyPtrHa16));
1253
1254     // ldu r12, lo16(LazyPtr)(r11)
1255     // lwzu r12, lo16(LazyPtr)(r11)
1256     const MCExpr *LazyPtrLo16 =
1257       PPCMCExpr::CreateLo(LazyPtrExpr, isDarwin, OutContext);
1258     EmitToStreamer(OutStreamer, MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
1259       .addReg(PPC::R12)
1260       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
1261       .addReg(PPC::R11));
1262
1263     // mtctr r12
1264     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
1265     // bctr
1266     EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BCTR));
1267
1268     OutStreamer.SwitchSection(LSPSection);
1269     OutStreamer.EmitLabel(LazyPtr);
1270     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1271
1272     MCSymbol *DyldStubBindingHelper =
1273       OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1274     if (isPPC64) {
1275       // .quad dyld_stub_binding_helper
1276       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
1277     } else {
1278       // .long dyld_stub_binding_helper
1279       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
1280     }
1281   }
1282
1283   OutStreamer.AddBlankLine();
1284 }
1285
1286
1287 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1288   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
1289
1290   // Darwin/PPC always uses mach-o.
1291   const TargetLoweringObjectFileMachO &TLOFMacho =
1292     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1293   MachineModuleInfoMachO &MMIMacho =
1294     MMI->getObjFileInfo<MachineModuleInfoMachO>();
1295
1296   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1297   if (!Stubs.empty())
1298     EmitFunctionStubs(Stubs);
1299
1300   if (MAI->doesSupportExceptionHandling() && MMI) {
1301     // Add the (possibly multiple) personalities to the set of global values.
1302     // Only referenced functions get into the Personalities list.
1303     const std::vector<const Function*> &Personalities = MMI->getPersonalities();
1304     for (std::vector<const Function*>::const_iterator I = Personalities.begin(),
1305          E = Personalities.end(); I != E; ++I) {
1306       if (*I) {
1307         MCSymbol *NLPSym = getSymbolWithGlobalValueBase(*I, "$non_lazy_ptr");
1308         MachineModuleInfoImpl::StubValueTy &StubSym =
1309           MMIMacho.getGVStubEntry(NLPSym);
1310         StubSym = MachineModuleInfoImpl::StubValueTy(getSymbol(*I), true);
1311       }
1312     }
1313   }
1314
1315   // Output stubs for dynamically-linked functions.
1316   Stubs = MMIMacho.GetGVStubList();
1317
1318   // Output macho stubs for external and common global variables.
1319   if (!Stubs.empty()) {
1320     // Switch with ".non_lazy_symbol_pointer" directive.
1321     OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1322     EmitAlignment(isPPC64 ? 3 : 2);
1323
1324     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1325       // L_foo$stub:
1326       OutStreamer.EmitLabel(Stubs[i].first);
1327       //   .indirect_symbol _foo
1328       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1329       OutStreamer.EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1330
1331       if (MCSym.getInt())
1332         // External to current translation unit.
1333         OutStreamer.EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1334       else
1335         // Internal to current translation unit.
1336         //
1337         // When we place the LSDA into the TEXT section, the type info pointers
1338         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1339         // However, sometimes the types are local to the file. So we need to
1340         // fill in the value for the NLP in those cases.
1341         OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(),
1342                                                       OutContext),
1343                               isPPC64 ? 8 : 4/*size*/);
1344     }
1345
1346     Stubs.clear();
1347     OutStreamer.AddBlankLine();
1348   }
1349
1350   Stubs = MMIMacho.GetHiddenGVStubList();
1351   if (!Stubs.empty()) {
1352     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
1353     EmitAlignment(isPPC64 ? 3 : 2);
1354
1355     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1356       // L_foo$stub:
1357       OutStreamer.EmitLabel(Stubs[i].first);
1358       //   .long _foo
1359       OutStreamer.EmitValue(MCSymbolRefExpr::
1360                             Create(Stubs[i].second.getPointer(),
1361                                    OutContext),
1362                             isPPC64 ? 8 : 4/*size*/);
1363     }
1364
1365     Stubs.clear();
1366     OutStreamer.AddBlankLine();
1367   }
1368
1369   // Funny Darwin hack: This flag tells the linker that no global symbols
1370   // contain code that falls through to other global symbols (e.g. the obvious
1371   // implementation of multiple entry points).  If this doesn't occur, the
1372   // linker can safely perform dead code stripping.  Since LLVM never generates
1373   // code that does this, it is always safe to set.
1374   OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1375
1376   return AsmPrinter::doFinalization(M);
1377 }
1378
1379 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1380 /// for a MachineFunction to the given output stream, in a format that the
1381 /// Darwin assembler can deal with.
1382 ///
1383 static AsmPrinter *createPPCAsmPrinterPass(TargetMachine &tm,
1384                                            MCStreamer &Streamer) {
1385   const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();
1386
1387   if (Subtarget->isDarwin())
1388     return new PPCDarwinAsmPrinter(tm, Streamer);
1389   return new PPCLinuxAsmPrinter(tm, Streamer);
1390 }
1391
1392 // Force static initialization.
1393 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1394   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1395   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1396   TargetRegistry::RegisterAsmPrinter(ThePPC64LETarget, createPPCAsmPrinterPass);
1397 }