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