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 #define DEBUG_TYPE "asmprinter"
  20 #include "PPC.h"
  21 #include "InstPrinter/PPCInstPrinter.h"
  22 #include "MCTargetDesc/PPCPredicates.h"
  23 #include "MCTargetDesc/PPCMCExpr.h"
  24 #include "PPCSubtarget.h"
  25 #include "PPCTargetMachine.h"
  26 #include "llvm/ADT/MapVector.h"
  27 #include "llvm/ADT/SmallString.h"
  28 #include "llvm/ADT/StringExtras.h"
  29 #include "llvm/Assembly/Writer.h"
  30 #include "llvm/CodeGen/AsmPrinter.h"
  31 #include "llvm/CodeGen/MachineFunctionPass.h"
  32 #include "llvm/CodeGen/MachineInstr.h"
  33 #include "llvm/CodeGen/MachineInstrBuilder.h"
  34 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
  35 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
  36 #include "llvm/DebugInfo.h"
  37 #include "llvm/IR/Constants.h"
  38 #include "llvm/IR/DerivedTypes.h"
  39 #include "llvm/IR/Module.h"
  40 #include "llvm/MC/MCAsmInfo.h"
  41 #include "llvm/MC/MCContext.h"
  42 #include "llvm/MC/MCExpr.h"
  43 #include "llvm/MC/MCInst.h"
  44 #include "llvm/MC/MCInstBuilder.h"
  45 #include "llvm/MC/MCSectionELF.h"
  46 #include "llvm/MC/MCSectionMachO.h"
  47 #include "llvm/MC/MCStreamer.h"
  48 #include "llvm/MC/MCSymbol.h"
  49 #include "llvm/Support/CommandLine.h"
  50 #include "llvm/Support/Debug.h"
  51 #include "llvm/Support/ELF.h"
  52 #include "llvm/Support/ErrorHandling.h"
  53 #include "llvm/Support/MathExtras.h"
  54 #include "llvm/Support/TargetRegistry.h"
  55 #include "llvm/Support/raw_ostream.h"
  56 #include "llvm/Target/Mangler.h"
  57 #include "llvm/Target/TargetInstrInfo.h"
  58 #include "llvm/Target/TargetOptions.h"
  59 #include "llvm/Target/TargetRegisterInfo.h"
  60 using namespace llvm;
  61
  62 namespace {
  63   class PPCAsmPrinter : public AsmPrinter {
  64   protected:
  65     MapVector<MCSymbol*, MCSymbol*> TOC;
  66     const PPCSubtarget &Subtarget;
  67     uint64_t TOCLabelID;
  68   public:
  69     explicit PPCAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
  70       : AsmPrinter(TM, Streamer),
  71         Subtarget(TM.getSubtarget<PPCSubtarget>()), TOCLabelID(0) {}
  72
  73     virtual const char *getPassName() const {
  74       return "PowerPC Assembly Printer";
  75     }
  76
  77     MCSymbol *lookUpOrCreateTOCEntry(MCSymbol *Sym);
  78
  79     virtual void EmitInstruction(const MachineInstr *MI);
  80
  81     void printOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
  82
  83     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
  84                          unsigned AsmVariant, const char *ExtraCode,
  85                          raw_ostream &O);
  86     bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
  87                                unsigned AsmVariant, const char *ExtraCode,
  88                                raw_ostream &O);
  89
  90     MachineLocation getDebugValueLocation(const MachineInstr *MI) const {
  91       MachineLocation Location;
  92       assert(MI->getNumOperands() == 4 && "Invalid no. of machine operands!");
  93       // Frame address.  Currently handles register +- offset only.
  94       if (MI->getOperand(0).isReg() && MI->getOperand(2).isImm())
  95         Location.set(MI->getOperand(0).getReg(), MI->getOperand(2).getImm());
  96       else {
  97         DEBUG(dbgs() << "DBG_VALUE instruction ignored! " << *MI << "\n");
  98       }
  99       return Location;
 100     }
 101   };
 102
 103   /// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux
 104   class PPCLinuxAsmPrinter : public PPCAsmPrinter {
 105   public:
 106     explicit PPCLinuxAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
 107       : PPCAsmPrinter(TM, Streamer) {}
 108
 109     virtual const char *getPassName() const {
 110       return "Linux PPC Assembly Printer";
 111     }
 112
 113     bool doFinalization(Module &M);
 114
 115     virtual void EmitFunctionEntryLabel();
 116
 117     void EmitFunctionBodyEnd();
 118   };
 119
 120   /// PPCDarwinAsmPrinter - PowerPC assembly printer, customized for Darwin/Mac
 121   /// OS X
 122   class PPCDarwinAsmPrinter : public PPCAsmPrinter {
 123   public:
 124     explicit PPCDarwinAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
 125       : PPCAsmPrinter(TM, Streamer) {}
 126
 127     virtual const char *getPassName() const {
 128       return "Darwin PPC Assembly Printer";
 129     }
 130
 131     bool doFinalization(Module &M);
 132     void EmitStartOfAsmFile(Module &M);
 133
 134     void EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs);
 135   };
 136 } // end of anonymous namespace
 137
 138 /// stripRegisterPrefix - This method strips the character prefix from a
 139 /// register name so that only the number is left.  Used by for linux asm.
 140 static const char *stripRegisterPrefix(const char *RegName) {
 141   switch (RegName[0]) {
 142     case 'r':
 143     case 'f':
 144     case 'v': return RegName + 1;
 145     case 'c': if (RegName[1] == 'r') return RegName + 2;
 146   }
 147
 148   return RegName;
 149 }
 150
 151 void PPCAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
 152                                  raw_ostream &O) {
 153   const MachineOperand &MO = MI->getOperand(OpNo);
 154
 155   switch (MO.getType()) {
 156   case MachineOperand::MO_Register: {
 157     const char *RegName = PPCInstPrinter::getRegisterName(MO.getReg());
 158     // Linux assembler (Others?) does not take register mnemonics.
 159     // FIXME - What about special registers used in mfspr/mtspr?
 160     if (!Subtarget.isDarwin()) RegName = stripRegisterPrefix(RegName);
 161     O << RegName;
 162     return;
 163   }
 164   case MachineOperand::MO_Immediate:
 165     O << MO.getImm();
 166     return;
 167
 168   case MachineOperand::MO_MachineBasicBlock:
 169     O << *MO.getMBB()->getSymbol();
 170     return;
 171   case MachineOperand::MO_JumpTableIndex:
 172     O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 173       << '_' << MO.getIndex();
 174     // FIXME: PIC relocation model
 175     return;
 176   case MachineOperand::MO_ConstantPoolIndex:
 177     O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber()
 178       << '_' << MO.getIndex();
 179     return;
 180   case MachineOperand::MO_BlockAddress:
 181     O << *GetBlockAddressSymbol(MO.getBlockAddress());
 182     return;
 183   case MachineOperand::MO_ExternalSymbol: {
 184     // Computing the address of an external symbol, not calling it.
 185     if (TM.getRelocationModel() == Reloc::Static) {
 186       O << *GetExternalSymbolSymbol(MO.getSymbolName());
 187       return;
 188     }
 189
 190     MCSymbol *NLPSym =
 191       OutContext.GetOrCreateSymbol(StringRef(MAI->getGlobalPrefix())+
 192                                    MO.getSymbolName()+"$non_lazy_ptr");
 193     MachineModuleInfoImpl::StubValueTy &StubSym =
 194       MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(NLPSym);
 195     if (StubSym.getPointer() == 0)
 196       StubSym = MachineModuleInfoImpl::
 197         StubValueTy(GetExternalSymbolSymbol(MO.getSymbolName()), true);
 198
 199     O << *NLPSym;
 200     return;
 201   }
 202   case MachineOperand::MO_GlobalAddress: {
 203     // Computing the address of a global symbol, not calling it.
 204     const GlobalValue *GV = MO.getGlobal();
 205     MCSymbol *SymToPrint;
 206
 207     // External or weakly linked global variables need non-lazily-resolved stubs
 208     if (TM.getRelocationModel() != Reloc::Static &&
 209         (GV->isDeclaration() || GV->isWeakForLinker())) {
 210       if (!GV->hasHiddenVisibility()) {
 211         SymToPrint = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
 212         MachineModuleInfoImpl::StubValueTy &StubSym =
 213           MMI->getObjFileInfo<MachineModuleInfoMachO>()
 214             .getGVStubEntry(SymToPrint);
 215         if (StubSym.getPointer() == 0)
 216           StubSym = MachineModuleInfoImpl::
 217             StubValueTy(Mang->getSymbol(GV), !GV->hasInternalLinkage());
 218       } else if (GV->isDeclaration() || GV->hasCommonLinkage() ||
 219                  GV->hasAvailableExternallyLinkage()) {
 220         SymToPrint = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
 221
 222         MachineModuleInfoImpl::StubValueTy &StubSym =
 223           MMI->getObjFileInfo<MachineModuleInfoMachO>().
 224                     getHiddenGVStubEntry(SymToPrint);
 225         if (StubSym.getPointer() == 0)
 226           StubSym = MachineModuleInfoImpl::
 227             StubValueTy(Mang->getSymbol(GV), !GV->hasInternalLinkage());
 228       } else {
 229         SymToPrint = Mang->getSymbol(GV);
 230       }
 231     } else {
 232       SymToPrint = Mang->getSymbol(GV);
 233     }
 234
 235     O << *SymToPrint;
 236
 237     printOffset(MO.getOffset(), O);
 238     return;
 239   }
 240
 241   default:
 242     O << "<unknown operand type: " << MO.getType() << ">";
 243     return;
 244   }
 245 }
 246
 247 /// PrintAsmOperand - Print out an operand for an inline asm expression.
 248 ///
 249 bool PPCAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
 250                                     unsigned AsmVariant,
 251                                     const char *ExtraCode, raw_ostream &O) {
 252   // Does this asm operand have a single letter operand modifier?
 253   if (ExtraCode && ExtraCode[0]) {
 254     if (ExtraCode[1] != 0) return true; // Unknown modifier.
 255
 256     switch (ExtraCode[0]) {
 257     default:
 258       // See if this is a generic print operand
 259       return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O);
 260     case 'c': // Don't print "$" before a global var name or constant.
 261       break; // PPC never has a prefix.
 262     case 'L': // Write second word of DImode reference.
 263       // Verify that this operand has two consecutive registers.
 264       if (!MI->getOperand(OpNo).isReg() ||
 265           OpNo+1 == MI->getNumOperands() ||
 266           !MI->getOperand(OpNo+1).isReg())
 267         return true;
 268       ++OpNo;   // Return the high-part.
 269       break;
 270     case 'I':
 271       // Write 'i' if an integer constant, otherwise nothing.  Used to print
 272       // addi vs add, etc.
 273       if (MI->getOperand(OpNo).isImm())
 274         O << "i";
 275       return false;
 276     }
 277   }
 278
 279   printOperand(MI, OpNo, O);
 280   return false;
 281 }
 282
 283 // At the moment, all inline asm memory operands are a single register.
 284 // In any case, the output of this routine should always be just one
 285 // assembler operand.
 286
 287 bool PPCAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
 288                                           unsigned AsmVariant,
 289                                           const char *ExtraCode,
 290                                           raw_ostream &O) {
 291   if (ExtraCode && ExtraCode[0]) {
 292     if (ExtraCode[1] != 0) return true; // Unknown modifier.
 293
 294     switch (ExtraCode[0]) {
 295     default: return true;  // Unknown modifier.
 296     case 'y': // A memory reference for an X-form instruction
 297       {
 298         const char *RegName = "r0";
 299         if (!Subtarget.isDarwin()) RegName = stripRegisterPrefix(RegName);
 300         O << RegName << ", ";
 301         printOperand(MI, OpNo, O);
 302         return false;
 303       }
 304     }
 305   }
 306
 307   assert(MI->getOperand(OpNo).isReg());
 308   O << "0(";
 309   printOperand(MI, OpNo, O);
 310   O << ")";
 311   return false;
 312 }
 313
 314
 315 /// lookUpOrCreateTOCEntry -- Given a symbol, look up whether a TOC entry
 316 /// exists for it.  If not, create one.  Then return a symbol that references
 317 /// the TOC entry.
 318 MCSymbol *PPCAsmPrinter::lookUpOrCreateTOCEntry(MCSymbol *Sym) {
 319
 320   MCSymbol *&TOCEntry = TOC[Sym];
 321
 322   // To avoid name clash check if the name already exists.
 323   while (TOCEntry == 0) {
 324     if (OutContext.LookupSymbol(Twine(MAI->getPrivateGlobalPrefix()) +
 325                                 "C" + Twine(TOCLabelID++)) == 0) {
 326       TOCEntry = GetTempSymbol("C", TOCLabelID);
 327     }
 328   }
 329
 330   return TOCEntry;
 331 }
 332
 333
 334 /// EmitInstruction -- Print out a single PowerPC MI in Darwin syntax to
 335 /// the current output stream.
 336 ///
 337 void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) {
 338   MCInst TmpInst;
 339
 340   // Lower multi-instruction pseudo operations.
 341   switch (MI->getOpcode()) {
 342   default: break;
 343   case TargetOpcode::DBG_VALUE: {
 344     if (!isVerbose() || !OutStreamer.hasRawTextSupport()) return;
 345
 346     SmallString<32> Str;
 347     raw_svector_ostream O(Str);
 348     unsigned NOps = MI->getNumOperands();
 349     assert(NOps==4);
 350     O << '\t' << MAI->getCommentString() << "DEBUG_VALUE: ";
 351     // cast away const; DIetc do not take const operands for some reason.
 352     DIVariable V(const_cast<MDNode *>(MI->getOperand(NOps-1).getMetadata()));
 353     O << V.getName();
 354     O << " <- ";
 355     // Frame address.  Currently handles register +- offset only.
 356     assert(MI->getOperand(0).isReg() && MI->getOperand(1).isImm());
 357     O << '['; printOperand(MI, 0, O); O << '+'; printOperand(MI, 1, O);
 358     O << ']';
 359     O << "+";
 360     printOperand(MI, NOps-2, O);
 361     OutStreamer.EmitRawText(O.str());
 362     return;
 363   }
 364
 365   case PPC::MovePCtoLR:
 366   case PPC::MovePCtoLR8: {
 367     // Transform %LR = MovePCtoLR
 368     // Into this, where the label is the PIC base:
 369     //     bl L1$pb
 370     // L1$pb:
 371     MCSymbol *PICBase = MF->getPICBaseSymbol();
 372
 373     // Emit the 'bl'.
 374     OutStreamer.EmitInstruction(MCInstBuilder(PPC::BL)
 375       // FIXME: We would like an efficient form for this, so we don't have to do
 376       // a lot of extra uniquing.
 377       .addExpr(MCSymbolRefExpr::Create(PICBase, OutContext)));
 378
 379     // Emit the label.
 380     OutStreamer.EmitLabel(PICBase);
 381     return;
 382   }
 383   case PPC::LDtocJTI:
 384   case PPC::LDtocCPT:
 385   case PPC::LDtoc: {
 386     // Transform %X3 = LDtoc <ga:@min1>, %X2
 387     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 388
 389     // Change the opcode to LD, and the global address operand to be a
 390     // reference to the TOC entry we will synthesize later.
 391     TmpInst.setOpcode(PPC::LD);
 392     const MachineOperand &MO = MI->getOperand(1);
 393
 394     // Map symbol -> label of TOC entry
 395     assert(MO.isGlobal() || MO.isCPI() || MO.isJTI());
 396     MCSymbol *MOSymbol = 0;
 397     if (MO.isGlobal())
 398       MOSymbol = Mang->getSymbol(MO.getGlobal());
 399     else if (MO.isCPI())
 400       MOSymbol = GetCPISymbol(MO.getIndex());
 401     else if (MO.isJTI())
 402       MOSymbol = GetJTISymbol(MO.getIndex());
 403
 404     MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol);
 405
 406     const MCExpr *Exp =
 407       MCSymbolRefExpr::Create(TOCEntry, MCSymbolRefExpr::VK_PPC_TOC_ENTRY,
 408                               OutContext);
 409     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 410     OutStreamer.EmitInstruction(TmpInst);
 411     return;
 412   }
 413
 414   case PPC::ADDIStocHA: {
 415     // Transform %Xd = ADDIStocHA %X2, <ga:@sym>
 416     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 417
 418     // Change the opcode to ADDIS8.  If the global address is external,
 419     // has common linkage, is a function address, or is a jump table
 420     // address, then generate a TOC entry and reference that.  Otherwise
 421     // reference the symbol directly.
 422     TmpInst.setOpcode(PPC::ADDIS8);
 423     const MachineOperand &MO = MI->getOperand(2);
 424     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI()) &&
 425            "Invalid operand for ADDIStocHA!");
 426     MCSymbol *MOSymbol = 0;
 427     bool IsExternal = false;
 428     bool IsFunction = false;
 429     bool IsCommon = false;
 430     bool IsAvailExt = false;
 431
 432     if (MO.isGlobal()) {
 433       const GlobalValue *GValue = MO.getGlobal();
 434       const GlobalAlias *GAlias = dyn_cast<GlobalAlias>(GValue);
 435       const GlobalValue *RealGValue = GAlias ?
 436         GAlias->resolveAliasedGlobal(false) : GValue;
 437       MOSymbol = Mang->getSymbol(RealGValue);
 438       const GlobalVariable *GVar = dyn_cast<GlobalVariable>(RealGValue);
 439       IsExternal = GVar && !GVar->hasInitializer();
 440       IsCommon = GVar && RealGValue->hasCommonLinkage();
 441       IsFunction = !GVar;
 442       IsAvailExt = GVar && RealGValue->hasAvailableExternallyLinkage();
 443     } else if (MO.isCPI())
 444       MOSymbol = GetCPISymbol(MO.getIndex());
 445     else if (MO.isJTI())
 446       MOSymbol = GetJTISymbol(MO.getIndex());
 447
 448     if (IsExternal || IsFunction || IsCommon || IsAvailExt || MO.isJTI())
 449       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 450
 451     const MCExpr *Exp =
 452       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC16_HA,
 453                               OutContext);
 454     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
 455     OutStreamer.EmitInstruction(TmpInst);
 456     return;
 457   }
 458   case PPC::LDtocL: {
 459     // Transform %Xd = LDtocL <ga:@sym>, %Xs
 460     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 461
 462     // Change the opcode to LD.  If the global address is external, has
 463     // common linkage, or is a jump table address, then reference the
 464     // associated TOC entry.  Otherwise reference the symbol directly.
 465     TmpInst.setOpcode(PPC::LD);
 466     const MachineOperand &MO = MI->getOperand(1);
 467     assert((MO.isGlobal() || MO.isJTI() || MO.isCPI()) &&
 468            "Invalid operand for LDtocL!");
 469     MCSymbol *MOSymbol = 0;
 470
 471     if (MO.isJTI())
 472       MOSymbol = lookUpOrCreateTOCEntry(GetJTISymbol(MO.getIndex()));
 473     else if (MO.isCPI())
 474       MOSymbol = GetCPISymbol(MO.getIndex());
 475     else if (MO.isGlobal()) {
 476       const GlobalValue *GValue = MO.getGlobal();
 477       const GlobalAlias *GAlias = dyn_cast<GlobalAlias>(GValue);
 478       const GlobalValue *RealGValue = GAlias ?
 479         GAlias->resolveAliasedGlobal(false) : GValue;
 480       MOSymbol = Mang->getSymbol(RealGValue);
 481       const GlobalVariable *GVar = dyn_cast<GlobalVariable>(RealGValue);
 482
 483       if (!GVar || !GVar->hasInitializer() || RealGValue->hasCommonLinkage() ||
 484           RealGValue->hasAvailableExternallyLinkage())
 485         MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 486     }
 487
 488     const MCExpr *Exp =
 489       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC16_LO,
 490                               OutContext);
 491     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 492     OutStreamer.EmitInstruction(TmpInst);
 493     return;
 494   }
 495   case PPC::ADDItocL: {
 496     // Transform %Xd = ADDItocL %Xs, <ga:@sym>
 497     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 498
 499     // Change the opcode to ADDI8.  If the global address is external, then
 500     // generate a TOC entry and reference that.  Otherwise reference the
 501     // symbol directly.
 502     TmpInst.setOpcode(PPC::ADDI8);
 503     const MachineOperand &MO = MI->getOperand(2);
 504     assert((MO.isGlobal() || MO.isCPI()) && "Invalid operand for ADDItocL");
 505     MCSymbol *MOSymbol = 0;
 506     bool IsExternal = false;
 507     bool IsFunction = false;
 508
 509     if (MO.isGlobal()) {
 510       const GlobalValue *GValue = MO.getGlobal();
 511       const GlobalAlias *GAlias = dyn_cast<GlobalAlias>(GValue);
 512       const GlobalValue *RealGValue = GAlias ?
 513         GAlias->resolveAliasedGlobal(false) : GValue;
 514       MOSymbol = Mang->getSymbol(RealGValue);
 515       const GlobalVariable *GVar = dyn_cast<GlobalVariable>(RealGValue);
 516       IsExternal = GVar && !GVar->hasInitializer();
 517       IsFunction = !GVar;
 518     } else if (MO.isCPI())
 519       MOSymbol = GetCPISymbol(MO.getIndex());
 520
 521     if (IsFunction || IsExternal)
 522       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 523
 524     const MCExpr *Exp =
 525       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TOC16_LO,
 526                               OutContext);
 527     TmpInst.getOperand(2) = MCOperand::CreateExpr(Exp);
 528     OutStreamer.EmitInstruction(TmpInst);
 529     return;
 530   }
 531   case PPC::ADDISgotTprelHA: {
 532     // Transform: %Xd = ADDISgotTprelHA %X2, <ga:@sym>
 533     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 534     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 535     const MachineOperand &MO = MI->getOperand(2);
 536     const GlobalValue *GValue = MO.getGlobal();
 537     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 538     const MCExpr *SymGotTprel =
 539       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL16_HA,
 540                               OutContext);
 541     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS8)
 542                                 .addReg(MI->getOperand(0).getReg())
 543                                 .addReg(PPC::X2)
 544                                 .addExpr(SymGotTprel));
 545     return;
 546   }
 547   case PPC::LDgotTprelL: {
 548     // Transform %Xd = LDgotTprelL <ga:@sym>, %Xs
 549     LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 550
 551     // Change the opcode to LD.
 552     TmpInst.setOpcode(PPC::LD);
 553     const MachineOperand &MO = MI->getOperand(1);
 554     const GlobalValue *GValue = MO.getGlobal();
 555     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 556     const MCExpr *Exp =
 557       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL16_LO,
 558                               OutContext);
 559     TmpInst.getOperand(1) = MCOperand::CreateExpr(Exp);
 560     OutStreamer.EmitInstruction(TmpInst);
 561     return;
 562   }
 563   case PPC::ADDIStlsgdHA: {
 564     // Transform: %Xd = ADDIStlsgdHA %X2, <ga:@sym>
 565     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsgd@ha
 566     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 567     const MachineOperand &MO = MI->getOperand(2);
 568     const GlobalValue *GValue = MO.getGlobal();
 569     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 570     const MCExpr *SymGotTlsGD =
 571       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD16_HA,
 572                               OutContext);
 573     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS8)
 574                                 .addReg(MI->getOperand(0).getReg())
 575                                 .addReg(PPC::X2)
 576                                 .addExpr(SymGotTlsGD));
 577     return;
 578   }
 579   case PPC::ADDItlsgdL: {
 580     // Transform: %Xd = ADDItlsgdL %Xs, <ga:@sym>
 581     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsgd@l
 582     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 583     const MachineOperand &MO = MI->getOperand(2);
 584     const GlobalValue *GValue = MO.getGlobal();
 585     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 586     const MCExpr *SymGotTlsGD =
 587       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD16_LO,
 588                               OutContext);
 589     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDI8)
 590                                 .addReg(MI->getOperand(0).getReg())
 591                                 .addReg(MI->getOperand(1).getReg())
 592                                 .addExpr(SymGotTlsGD));
 593     return;
 594   }
 595   case PPC::GETtlsADDR: {
 596     // Transform: %X3 = GETtlsADDR %X3, <ga:@sym>
 597     // Into:      BL8_NOP_TLSGD __tls_get_addr(sym@tlsgd)
 598     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 599
 600     StringRef Name = "__tls_get_addr";
 601     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 602     const MCSymbolRefExpr *TlsRef =
 603       MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);
 604     const MachineOperand &MO = MI->getOperand(2);
 605     const GlobalValue *GValue = MO.getGlobal();
 606     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 607     const MCExpr *SymVar =
 608       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSGD,
 609                               OutContext);
 610     OutStreamer.EmitInstruction(MCInstBuilder(PPC::BL8_NOP_TLSGD)
 611                                 .addExpr(TlsRef)
 612                                 .addExpr(SymVar));
 613     return;
 614   }
 615   case PPC::ADDIStlsldHA: {
 616     // Transform: %Xd = ADDIStlsldHA %X2, <ga:@sym>
 617     // Into:      %Xd = ADDIS8 %X2, sym@got@tlsld@ha
 618     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 619     const MachineOperand &MO = MI->getOperand(2);
 620     const GlobalValue *GValue = MO.getGlobal();
 621     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 622     const MCExpr *SymGotTlsLD =
 623       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD16_HA,
 624                               OutContext);
 625     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS8)
 626                                 .addReg(MI->getOperand(0).getReg())
 627                                 .addReg(PPC::X2)
 628                                 .addExpr(SymGotTlsLD));
 629     return;
 630   }
 631   case PPC::ADDItlsldL: {
 632     // Transform: %Xd = ADDItlsldL %Xs, <ga:@sym>
 633     // Into:      %Xd = ADDI8 %Xs, sym@got@tlsld@l
 634     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 635     const MachineOperand &MO = MI->getOperand(2);
 636     const GlobalValue *GValue = MO.getGlobal();
 637     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 638     const MCExpr *SymGotTlsLD =
 639       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD16_LO,
 640                               OutContext);
 641     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDI8)
 642                                 .addReg(MI->getOperand(0).getReg())
 643                                 .addReg(MI->getOperand(1).getReg())
 644                                 .addExpr(SymGotTlsLD));
 645     return;
 646   }
 647   case PPC::GETtlsldADDR: {
 648     // Transform: %X3 = GETtlsldADDR %X3, <ga:@sym>
 649     // Into:      BL8_NOP_TLSLD __tls_get_addr(sym@tlsld)
 650     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 651
 652     StringRef Name = "__tls_get_addr";
 653     MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);
 654     const MCSymbolRefExpr *TlsRef =
 655       MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);
 656     const MachineOperand &MO = MI->getOperand(2);
 657     const GlobalValue *GValue = MO.getGlobal();
 658     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 659     const MCExpr *SymVar =
 660       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSLD,
 661                               OutContext);
 662     OutStreamer.EmitInstruction(MCInstBuilder(PPC::BL8_NOP_TLSLD)
 663                                 .addExpr(TlsRef)
 664                                 .addExpr(SymVar));
 665     return;
 666   }
 667   case PPC::ADDISdtprelHA: {
 668     // Transform: %Xd = ADDISdtprelHA %X3, <ga:@sym>
 669     // Into:      %Xd = ADDIS8 %X3, sym@dtprel@ha
 670     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 671     const MachineOperand &MO = MI->getOperand(2);
 672     const GlobalValue *GValue = MO.getGlobal();
 673     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 674     const MCExpr *SymDtprel =
 675       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL16_HA,
 676                               OutContext);
 677     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS8)
 678                                 .addReg(MI->getOperand(0).getReg())
 679                                 .addReg(PPC::X3)
 680                                 .addExpr(SymDtprel));
 681     return;
 682   }
 683   case PPC::ADDIdtprelL: {
 684     // Transform: %Xd = ADDIdtprelL %Xs, <ga:@sym>
 685     // Into:      %Xd = ADDI8 %Xs, sym@dtprel@l
 686     assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");
 687     const MachineOperand &MO = MI->getOperand(2);
 688     const GlobalValue *GValue = MO.getGlobal();
 689     MCSymbol *MOSymbol = Mang->getSymbol(GValue);
 690     const MCExpr *SymDtprel =
 691       MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL16_LO,
 692                               OutContext);
 693     OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDI8)
 694                                 .addReg(MI->getOperand(0).getReg())
 695                                 .addReg(MI->getOperand(1).getReg())
 696                                 .addExpr(SymDtprel));
 697     return;
 698   }
 699   case PPC::MFCRpseud:
 700   case PPC::MFCR8pseud:
 701     // Transform: %R3 = MFCRpseud %CR7
 702     // Into:      %R3 = MFCR      ;; cr7
 703     OutStreamer.AddComment(PPCInstPrinter::
 704                            getRegisterName(MI->getOperand(1).getReg()));
 705     OutStreamer.EmitInstruction(MCInstBuilder(Subtarget.isPPC64() ? PPC::MFCR8 : PPC::MFCR)
 706       .addReg(MI->getOperand(0).getReg()));
 707     return;
 708   case PPC::SYNC:
 709     // In Book E sync is called msync, handle this special case here...
 710     if (Subtarget.isBookE()) {
 711       OutStreamer.EmitRawText(StringRef("\tmsync"));
 712       return;
 713     }
 714   }
 715
 716   LowerPPCMachineInstrToMCInst(MI, TmpInst, *this, Subtarget.isDarwin());
 717   OutStreamer.EmitInstruction(TmpInst);
 718 }
 719
 720 void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
 721   if (!Subtarget.isPPC64())  // linux/ppc32 - Normal entry label.
 722     return AsmPrinter::EmitFunctionEntryLabel();
 723
 724   // Emit an official procedure descriptor.
 725   MCSectionSubPair Current = OutStreamer.getCurrentSection();
 726   const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".opd",
 727       ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 728       SectionKind::getReadOnly());
 729   OutStreamer.SwitchSection(Section);
 730   OutStreamer.EmitLabel(CurrentFnSym);
 731   OutStreamer.EmitValueToAlignment(8);
 732   MCSymbol *Symbol1 =
 733     OutContext.GetOrCreateSymbol(".L." + Twine(CurrentFnSym->getName()));
 734   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
 735   // entry point.
 736   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol1, OutContext),
 737                         8 /*size*/);
 738   MCSymbol *Symbol2 = OutContext.GetOrCreateSymbol(StringRef(".TOC."));
 739   // Generates a R_PPC64_TOC relocation for TOC base insertion.
 740   OutStreamer.EmitValue(MCSymbolRefExpr::Create(Symbol2,
 741                         MCSymbolRefExpr::VK_PPC_TOC, OutContext),
 742                         8/*size*/);
 743   // Emit a null environment pointer.
 744   OutStreamer.EmitIntValue(0, 8 /* size */);
 745   OutStreamer.SwitchSection(Current.first, Current.second);
 746
 747   MCSymbol *RealFnSym = OutContext.GetOrCreateSymbol(
 748                           ".L." + Twine(CurrentFnSym->getName()));
 749   OutStreamer.EmitLabel(RealFnSym);
 750   CurrentFnSymForSize = RealFnSym;
 751 }
 752
 753
 754 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
 755   const DataLayout *TD = TM.getDataLayout();
 756
 757   bool isPPC64 = TD->getPointerSizeInBits() == 64;
 758
 759   if (isPPC64 && !TOC.empty()) {
 760     const MCSectionELF *Section = OutStreamer.getContext().getELFSection(".toc",
 761         ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC,
 762         SectionKind::getReadOnly());
 763     OutStreamer.SwitchSection(Section);
 764
 765     for (MapVector<MCSymbol*, MCSymbol*>::iterator I = TOC.begin(),
 766          E = TOC.end(); I != E; ++I) {
 767       OutStreamer.EmitLabel(I->second);
 768       MCSymbol *S = OutContext.GetOrCreateSymbol(I->first->getName());
 769       OutStreamer.EmitTCEntry(*S);
 770     }
 771   }
 772
 773   MachineModuleInfoELF &MMIELF =
 774     MMI->getObjFileInfo<MachineModuleInfoELF>();
 775
 776   MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
 777   if (!Stubs.empty()) {
 778     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
 779     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 780       // L_foo$stub:
 781       OutStreamer.EmitLabel(Stubs[i].first);
 782       //   .long _foo
 783       OutStreamer.EmitValue(MCSymbolRefExpr::Create(Stubs[i].second.getPointer(),
 784                                                     OutContext),
 785                             isPPC64 ? 8 : 4/*size*/, 0/*addrspace*/);
 786     }
 787
 788     Stubs.clear();
 789     OutStreamer.AddBlankLine();
 790   }
 791
 792   return AsmPrinter::doFinalization(M);
 793 }
 794
 795 /// EmitFunctionBodyEnd - Print the traceback table before the .size
 796 /// directive.
 797 ///
 798 void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
 799   // Only the 64-bit target requires a traceback table.  For now,
 800   // we only emit the word of zeroes that GDB requires to find
 801   // the end of the function, and zeroes for the eight-byte
 802   // mandatory fields.
 803   // FIXME: We should fill in the eight-byte mandatory fields as described in
 804   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
 805   // currently make use of these fields).
 806   if (Subtarget.isPPC64()) {
 807     OutStreamer.EmitIntValue(0, 4/*size*/);
 808     OutStreamer.EmitIntValue(0, 8/*size*/);
 809   }
 810 }
 811
 812 void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) {
 813   static const char *const CPUDirectives[] = {
 814     "",
 815     "ppc",
 816     "ppc440",
 817     "ppc601",
 818     "ppc602",
 819     "ppc603",
 820     "ppc7400",
 821     "ppc750",
 822     "ppc970",
 823     "ppcA2",
 824     "ppce500mc",
 825     "ppce5500",
 826     "power3",
 827     "power4",
 828     "power5",
 829     "power5x",
 830     "power6",
 831     "power6x",
 832     "power7",
 833     "ppc64"
 834   };
 835
 836   unsigned Directive = Subtarget.getDarwinDirective();
 837   if (Subtarget.hasMFOCRF() && Directive < PPC::DIR_970)
 838     Directive = PPC::DIR_970;
 839   if (Subtarget.hasAltivec() && Directive < PPC::DIR_7400)
 840     Directive = PPC::DIR_7400;
 841   if (Subtarget.isPPC64() && Directive < PPC::DIR_64)
 842     Directive = PPC::DIR_64;
 843   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
 844
 845   // FIXME: This is a total hack, finish mc'izing the PPC backend.
 846   if (OutStreamer.hasRawTextSupport()) {
 847     assert(Directive < sizeof(CPUDirectives) / sizeof(*CPUDirectives) &&
 848            "CPUDirectives[] might not be up-to-date!");
 849     OutStreamer.EmitRawText("\t.machine " + Twine(CPUDirectives[Directive]));
 850   }
 851
 852   // Prime text sections so they are adjacent.  This reduces the likelihood a
 853   // large data or debug section causes a branch to exceed 16M limit.
 854   const TargetLoweringObjectFileMachO &TLOFMacho =
 855     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
 856   OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection());
 857   if (TM.getRelocationModel() == Reloc::PIC_) {
 858     OutStreamer.SwitchSection(
 859            OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
 860                                       MCSectionMachO::S_SYMBOL_STUBS |
 861                                       MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 862                                       32, SectionKind::getText()));
 863   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
 864     OutStreamer.SwitchSection(
 865            OutContext.getMachOSection("__TEXT","__symbol_stub1",
 866                                       MCSectionMachO::S_SYMBOL_STUBS |
 867                                       MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 868                                       16, SectionKind::getText()));
 869   }
 870   OutStreamer.SwitchSection(getObjFileLowering().getTextSection());
 871 }
 872
 873 static MCSymbol *GetLazyPtr(MCSymbol *Sym, MCContext &Ctx) {
 874   // Remove $stub suffix, add $lazy_ptr.
 875   StringRef NoStub = Sym->getName().substr(0, Sym->getName().size()-5);
 876   return Ctx.GetOrCreateSymbol(NoStub + "$lazy_ptr");
 877 }
 878
 879 static MCSymbol *GetAnonSym(MCSymbol *Sym, MCContext &Ctx) {
 880   // Add $tmp suffix to $stub, yielding $stub$tmp.
 881   return Ctx.GetOrCreateSymbol(Sym->getName() + "$tmp");
 882 }
 883
 884 void PPCDarwinAsmPrinter::
 885 EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) {
 886   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
 887
 888   const TargetLoweringObjectFileMachO &TLOFMacho =
 889     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
 890
 891   // .lazy_symbol_pointer
 892   const MCSection *LSPSection = TLOFMacho.getLazySymbolPointerSection();
 893
 894   // Output stubs for dynamically-linked functions
 895   if (TM.getRelocationModel() == Reloc::PIC_) {
 896     const MCSection *StubSection =
 897     OutContext.getMachOSection("__TEXT", "__picsymbolstub1",
 898                                MCSectionMachO::S_SYMBOL_STUBS |
 899                                MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 900                                32, SectionKind::getText());
 901     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 902       OutStreamer.SwitchSection(StubSection);
 903       EmitAlignment(4);
 904
 905       MCSymbol *Stub = Stubs[i].first;
 906       MCSymbol *RawSym = Stubs[i].second.getPointer();
 907       MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
 908       MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext);
 909
 910       OutStreamer.EmitLabel(Stub);
 911       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
 912
 913       const MCExpr *Anon = MCSymbolRefExpr::Create(AnonSymbol, OutContext);
 914       const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
 915       const MCExpr *Sub =
 916         MCBinaryExpr::CreateSub(LazyPtrExpr, Anon, OutContext);
 917
 918       // mflr r0
 919       OutStreamer.EmitInstruction(MCInstBuilder(PPC::MFLR).addReg(PPC::R0));
 920       // bcl 20, 31, AnonSymbol
 921       OutStreamer.EmitInstruction(MCInstBuilder(PPC::BCLalways).addExpr(Anon));
 922       OutStreamer.EmitLabel(AnonSymbol);
 923       // mflr r11
 924       OutStreamer.EmitInstruction(MCInstBuilder(PPC::MFLR).addReg(PPC::R11));
 925       // addis r11, r11, ha16(LazyPtr - AnonSymbol)
 926       const MCExpr *SubHa16 = PPCMCExpr::CreateHa16(Sub, OutContext);
 927       OutStreamer.EmitInstruction(MCInstBuilder(PPC::ADDIS)
 928         .addReg(PPC::R11)
 929         .addReg(PPC::R11)
 930         .addExpr(SubHa16));
 931       // mtlr r0
 932       OutStreamer.EmitInstruction(MCInstBuilder(PPC::MTLR).addReg(PPC::R0));
 933
 934       // ldu r12, lo16(LazyPtr - AnonSymbol)(r11)
 935       // lwzu r12, lo16(LazyPtr - AnonSymbol)(r11)
 936       const MCExpr *SubLo16 = PPCMCExpr::CreateLo16(Sub, OutContext);
 937       OutStreamer.EmitInstruction(MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
 938         .addReg(PPC::R12)
 939         .addExpr(SubLo16).addExpr(SubLo16)
 940         .addReg(PPC::R11));
 941       // mtctr r12
 942       OutStreamer.EmitInstruction(MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
 943       // bctr
 944       OutStreamer.EmitInstruction(MCInstBuilder(PPC::BCTR));
 945
 946       OutStreamer.SwitchSection(LSPSection);
 947       OutStreamer.EmitLabel(LazyPtr);
 948       OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
 949
 950       MCSymbol *DyldStubBindingHelper =
 951         OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
 952       if (isPPC64) {
 953         // .quad dyld_stub_binding_helper
 954         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
 955       } else {
 956         // .long dyld_stub_binding_helper
 957         OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
 958       }
 959     }
 960     OutStreamer.AddBlankLine();
 961     return;
 962   }
 963
 964   const MCSection *StubSection =
 965     OutContext.getMachOSection("__TEXT","__symbol_stub1",
 966                                MCSectionMachO::S_SYMBOL_STUBS |
 967                                MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 968                                16, SectionKind::getText());
 969   for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 970     MCSymbol *Stub = Stubs[i].first;
 971     MCSymbol *RawSym = Stubs[i].second.getPointer();
 972     MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext);
 973     const MCExpr *LazyPtrExpr = MCSymbolRefExpr::Create(LazyPtr, OutContext);
 974
 975     OutStreamer.SwitchSection(StubSection);
 976     EmitAlignment(4);
 977     OutStreamer.EmitLabel(Stub);
 978     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
 979
 980     // lis r11, ha16(LazyPtr)
 981     const MCExpr *LazyPtrHa16 = PPCMCExpr::CreateHa16(LazyPtrExpr, OutContext);
 982     OutStreamer.EmitInstruction(MCInstBuilder(PPC::LIS)
 983       .addReg(PPC::R11)
 984       .addExpr(LazyPtrHa16));
 985
 986     // ldu r12, lo16(LazyPtr)(r11)
 987     // lwzu r12, lo16(LazyPtr)(r11)
 988     const MCExpr *LazyPtrLo16 = PPCMCExpr::CreateLo16(LazyPtrExpr, OutContext);
 989     OutStreamer.EmitInstruction(MCInstBuilder(isPPC64 ? PPC::LDU : PPC::LWZU)
 990       .addReg(PPC::R12)
 991       .addExpr(LazyPtrLo16).addExpr(LazyPtrLo16)
 992       .addReg(PPC::R11));
 993
 994     // mtctr r12
 995     OutStreamer.EmitInstruction(MCInstBuilder(PPC::MTCTR).addReg(PPC::R12));
 996     // bctr
 997     OutStreamer.EmitInstruction(MCInstBuilder(PPC::BCTR));
 998
 999     OutStreamer.SwitchSection(LSPSection);
1000     OutStreamer.EmitLabel(LazyPtr);
1001     OutStreamer.EmitSymbolAttribute(RawSym, MCSA_IndirectSymbol);
1002
1003     MCSymbol *DyldStubBindingHelper =
1004       OutContext.GetOrCreateSymbol(StringRef("dyld_stub_binding_helper"));
1005     if (isPPC64) {
1006       // .quad dyld_stub_binding_helper
1007       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 8);
1008     } else {
1009       // .long dyld_stub_binding_helper
1010       OutStreamer.EmitSymbolValue(DyldStubBindingHelper, 4);
1011     }
1012   }
1013
1014   OutStreamer.AddBlankLine();
1015 }
1016
1017
1018 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
1019   bool isPPC64 = TM.getDataLayout()->getPointerSizeInBits() == 64;
1020
1021   // Darwin/PPC always uses mach-o.
1022   const TargetLoweringObjectFileMachO &TLOFMacho =
1023     static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
1024   MachineModuleInfoMachO &MMIMacho =
1025     MMI->getObjFileInfo<MachineModuleInfoMachO>();
1026
1027   MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetFnStubList();
1028   if (!Stubs.empty())
1029     EmitFunctionStubs(Stubs);
1030
1031   if (MAI->doesSupportExceptionHandling() && MMI) {
1032     // Add the (possibly multiple) personalities to the set of global values.
1033     // Only referenced functions get into the Personalities list.
1034     const std::vector<const Function*> &Personalities = MMI->getPersonalities();
1035     for (std::vector<const Function*>::const_iterator I = Personalities.begin(),
1036          E = Personalities.end(); I != E; ++I) {
1037       if (*I) {
1038         MCSymbol *NLPSym = GetSymbolWithGlobalValueBase(*I, "$non_lazy_ptr");
1039         MachineModuleInfoImpl::StubValueTy &StubSym =
1040           MMIMacho.getGVStubEntry(NLPSym);
1041         StubSym = MachineModuleInfoImpl::StubValueTy(Mang->getSymbol(*I), true);
1042       }
1043     }
1044   }
1045
1046   // Output stubs for dynamically-linked functions.
1047   Stubs = MMIMacho.GetGVStubList();
1048
1049   // Output macho stubs for external and common global variables.
1050   if (!Stubs.empty()) {
1051     // Switch with ".non_lazy_symbol_pointer" directive.
1052     OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1053     EmitAlignment(isPPC64 ? 3 : 2);
1054
1055     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1056       // L_foo$stub:
1057       OutStreamer.EmitLabel(Stubs[i].first);
1058       //   .indirect_symbol _foo
1059       MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
1060       OutStreamer.EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
1061
1062       if (MCSym.getInt())
1063         // External to current translation unit.
1064         OutStreamer.EmitIntValue(0, isPPC64 ? 8 : 4/*size*/);
1065       else
1066         // Internal to current translation unit.
1067         //
1068         // When we place the LSDA into the TEXT section, the type info pointers
1069         // need to be indirect and pc-rel. We accomplish this by using NLPs.
1070         // However, sometimes the types are local to the file. So we need to
1071         // fill in the value for the NLP in those cases.
1072         OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(),
1073                                                       OutContext),
1074                               isPPC64 ? 8 : 4/*size*/);
1075     }
1076
1077     Stubs.clear();
1078     OutStreamer.AddBlankLine();
1079   }
1080
1081   Stubs = MMIMacho.GetHiddenGVStubList();
1082   if (!Stubs.empty()) {
1083     OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
1084     EmitAlignment(isPPC64 ? 3 : 2);
1085
1086     for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1087       // L_foo$stub:
1088       OutStreamer.EmitLabel(Stubs[i].first);
1089       //   .long _foo
1090       OutStreamer.EmitValue(MCSymbolRefExpr::
1091                             Create(Stubs[i].second.getPointer(),
1092                                    OutContext),
1093                             isPPC64 ? 8 : 4/*size*/);
1094     }
1095
1096     Stubs.clear();
1097     OutStreamer.AddBlankLine();
1098   }
1099
1100   // Funny Darwin hack: This flag tells the linker that no global symbols
1101   // contain code that falls through to other global symbols (e.g. the obvious
1102   // implementation of multiple entry points).  If this doesn't occur, the
1103   // linker can safely perform dead code stripping.  Since LLVM never generates
1104   // code that does this, it is always safe to set.
1105   OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1106
1107   return AsmPrinter::doFinalization(M);
1108 }
1109
1110 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1111 /// for a MachineFunction to the given output stream, in a format that the
1112 /// Darwin assembler can deal with.
1113 ///
1114 static AsmPrinter *createPPCAsmPrinterPass(TargetMachine &tm,
1115                                            MCStreamer &Streamer) {
1116   const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();
1117
1118   if (Subtarget->isDarwin())
1119     return new PPCDarwinAsmPrinter(tm, Streamer);
1120   return new PPCLinuxAsmPrinter(tm, Streamer);
1121 }
1122
1123 // Force static initialization.
1124 extern "C" void LLVMInitializePowerPCAsmPrinter() {
1125   TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
1126   TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
1127 }