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