lib/Target/PowerPC/AsmPrinter/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 "PPCPredicates.h"
  22 #include "PPCTargetMachine.h"
  23 #include "PPCSubtarget.h"
  24 #include "llvm/Constants.h"
  25 #include "llvm/DerivedTypes.h"
  26 #include "llvm/Module.h"
  27 #include "llvm/MDNode.h"
  28 #include "llvm/Assembly/Writer.h"
  29 #include "llvm/CodeGen/AsmPrinter.h"
  30 #include "llvm/CodeGen/DwarfWriter.h"
  31 #include "llvm/CodeGen/MachineModuleInfo.h"
  32 #include "llvm/CodeGen/MachineFunctionPass.h"
  33 #include "llvm/CodeGen/MachineInstr.h"
  34 #include "llvm/CodeGen/MachineInstrBuilder.h"
  35 #include "llvm/Support/Mangler.h"
  36 #include "llvm/Support/MathExtras.h"
  37 #include "llvm/Support/CommandLine.h"
  38 #include "llvm/Support/Debug.h"
  39 #include "llvm/Support/ErrorHandling.h"
  40 #include "llvm/Support/Compiler.h"
  41 #include "llvm/Support/raw_ostream.h"
  42 #include "llvm/Target/TargetAsmInfo.h"
  43 #include "llvm/Target/TargetRegisterInfo.h"
  44 #include "llvm/Target/TargetInstrInfo.h"
  45 #include "llvm/Target/TargetOptions.h"
  46 #include "llvm/ADT/Statistic.h"
  47 #include "llvm/ADT/StringExtras.h"
  48 #include "llvm/ADT/StringSet.h"
  49 using namespace llvm;
  50
  51 STATISTIC(EmittedInsts, "Number of machine instrs printed");
  52
  53 namespace {
  54   class VISIBILITY_HIDDEN PPCAsmPrinter : public AsmPrinter {
  55   protected:
  56     StringSet<> FnStubs, GVStubs, HiddenGVStubs;
  57     const PPCSubtarget &Subtarget;
  58   public:
  59     explicit PPCAsmPrinter(raw_ostream &O, TargetMachine &TM,
  60                            const TargetAsmInfo *T, bool V)
  61       : AsmPrinter(O, TM, T, V),
  62         Subtarget(TM.getSubtarget<PPCSubtarget>()) {}
  63
  64     virtual const char *getPassName() const {
  65       return "PowerPC Assembly Printer";
  66     }
  67
  68     PPCTargetMachine &getTM() {
  69       return static_cast<PPCTargetMachine&>(TM);
  70     }
  71
  72     unsigned enumRegToMachineReg(unsigned enumReg) {
  73       switch (enumReg) {
  74       default: LLVM_UNREACHABLE("Unhandled register!");
  75       case PPC::CR0:  return  0;
  76       case PPC::CR1:  return  1;
  77       case PPC::CR2:  return  2;
  78       case PPC::CR3:  return  3;
  79       case PPC::CR4:  return  4;
  80       case PPC::CR5:  return  5;
  81       case PPC::CR6:  return  6;
  82       case PPC::CR7:  return  7;
  83       }
  84       llvm_unreachable();
  85     }
  86
  87     /// printInstruction - This method is automatically generated by tablegen
  88     /// from the instruction set description.  This method returns true if the
  89     /// machine instruction was sufficiently described to print it, otherwise it
  90     /// returns false.
  91     bool printInstruction(const MachineInstr *MI);
  92
  93     void printMachineInstruction(const MachineInstr *MI);
  94     void printOp(const MachineOperand &MO);
  95
  96     /// stripRegisterPrefix - This method strips the character prefix from a
  97     /// register name so that only the number is left.  Used by for linux asm.
  98     const char *stripRegisterPrefix(const char *RegName) {
  99       switch (RegName[0]) {
 100       case 'r':
 101       case 'f':
 102       case 'v': return RegName + 1;
 103       case 'c': if (RegName[1] == 'r') return RegName + 2;
 104       }
 105
 106       return RegName;
 107     }
 108
 109     /// printRegister - Print register according to target requirements.
 110     ///
 111     void printRegister(const MachineOperand &MO, bool R0AsZero) {
 112       unsigned RegNo = MO.getReg();
 113       assert(TargetRegisterInfo::isPhysicalRegister(RegNo) && "Not physreg??");
 114
 115       // If we should use 0 for R0.
 116       if (R0AsZero && RegNo == PPC::R0) {
 117         O << "0";
 118         return;
 119       }
 120
 121       const char *RegName = TM.getRegisterInfo()->get(RegNo).AsmName;
 122       // Linux assembler (Others?) does not take register mnemonics.
 123       // FIXME - What about special registers used in mfspr/mtspr?
 124       if (!Subtarget.isDarwin()) RegName = stripRegisterPrefix(RegName);
 125       O << RegName;
 126     }
 127
 128     void printOperand(const MachineInstr *MI, unsigned OpNo) {
 129       const MachineOperand &MO = MI->getOperand(OpNo);
 130       if (MO.isReg()) {
 131         printRegister(MO, false);
 132       } else if (MO.isImm()) {
 133         O << MO.getImm();
 134       } else {
 135         printOp(MO);
 136       }
 137     }
 138
 139     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
 140                          unsigned AsmVariant, const char *ExtraCode);
 141     bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
 142                                unsigned AsmVariant, const char *ExtraCode);
 143
 144
 145     void printS5ImmOperand(const MachineInstr *MI, unsigned OpNo) {
 146       char value = MI->getOperand(OpNo).getImm();
 147       value = (value << (32-5)) >> (32-5);
 148       O << (int)value;
 149     }
 150     void printU5ImmOperand(const MachineInstr *MI, unsigned OpNo) {
 151       unsigned char value = MI->getOperand(OpNo).getImm();
 152       assert(value <= 31 && "Invalid u5imm argument!");
 153       O << (unsigned int)value;
 154     }
 155     void printU6ImmOperand(const MachineInstr *MI, unsigned OpNo) {
 156       unsigned char value = MI->getOperand(OpNo).getImm();
 157       assert(value <= 63 && "Invalid u6imm argument!");
 158       O << (unsigned int)value;
 159     }
 160     void printS16ImmOperand(const MachineInstr *MI, unsigned OpNo) {
 161       O << (short)MI->getOperand(OpNo).getImm();
 162     }
 163     void printU16ImmOperand(const MachineInstr *MI, unsigned OpNo) {
 164       O << (unsigned short)MI->getOperand(OpNo).getImm();
 165     }
 166     void printS16X4ImmOperand(const MachineInstr *MI, unsigned OpNo) {
 167       if (MI->getOperand(OpNo).isImm()) {
 168         O << (short)(MI->getOperand(OpNo).getImm()*4);
 169       } else {
 170         O << "lo16(";
 171         printOp(MI->getOperand(OpNo));
 172         if (TM.getRelocationModel() == Reloc::PIC_)
 173           O << "-\"L" << getFunctionNumber() << "$pb\")";
 174         else
 175           O << ')';
 176       }
 177     }
 178     void printBranchOperand(const MachineInstr *MI, unsigned OpNo) {
 179       // Branches can take an immediate operand.  This is used by the branch
 180       // selection pass to print $+8, an eight byte displacement from the PC.
 181       if (MI->getOperand(OpNo).isImm()) {
 182         O << "$+" << MI->getOperand(OpNo).getImm()*4;
 183       } else {
 184         printOp(MI->getOperand(OpNo));
 185       }
 186     }
 187     void printCallOperand(const MachineInstr *MI, unsigned OpNo) {
 188       const MachineOperand &MO = MI->getOperand(OpNo);
 189       if (TM.getRelocationModel() != Reloc::Static) {
 190         if (MO.getType() == MachineOperand::MO_GlobalAddress) {
 191           GlobalValue *GV = MO.getGlobal();
 192           if (GV->isDeclaration() || GV->isWeakForLinker()) {
 193             // Dynamically-resolved functions need a stub for the function.
 194             std::string Name = Mang->getValueName(GV);
 195             FnStubs.insert(Name);
 196             printSuffixedName(Name, "$stub");
 197             return;
 198           }
 199         }
 200         if (MO.getType() == MachineOperand::MO_ExternalSymbol) {
 201           std::string Name(TAI->getGlobalPrefix()); Name += MO.getSymbolName();
 202           FnStubs.insert(Name);
 203           printSuffixedName(Name, "$stub");
 204           return;
 205         }
 206       }
 207
 208       printOp(MI->getOperand(OpNo));
 209     }
 210     void printAbsAddrOperand(const MachineInstr *MI, unsigned OpNo) {
 211      O << (int)MI->getOperand(OpNo).getImm()*4;
 212     }
 213     void printPICLabel(const MachineInstr *MI, unsigned OpNo) {
 214       O << "\"L" << getFunctionNumber() << "$pb\"\n";
 215       O << "\"L" << getFunctionNumber() << "$pb\":";
 216     }
 217     void printSymbolHi(const MachineInstr *MI, unsigned OpNo) {
 218       if (MI->getOperand(OpNo).isImm()) {
 219         printS16ImmOperand(MI, OpNo);
 220       } else {
 221         if (Subtarget.isDarwin()) O << "ha16(";
 222         printOp(MI->getOperand(OpNo));
 223         if (TM.getRelocationModel() == Reloc::PIC_)
 224           O << "-\"L" << getFunctionNumber() << "$pb\"";
 225         if (Subtarget.isDarwin())
 226           O << ')';
 227         else
 228           O << "@ha";
 229       }
 230     }
 231     void printSymbolLo(const MachineInstr *MI, unsigned OpNo) {
 232       if (MI->getOperand(OpNo).isImm()) {
 233         printS16ImmOperand(MI, OpNo);
 234       } else {
 235         if (Subtarget.isDarwin()) O << "lo16(";
 236         printOp(MI->getOperand(OpNo));
 237         if (TM.getRelocationModel() == Reloc::PIC_)
 238           O << "-\"L" << getFunctionNumber() << "$pb\"";
 239         if (Subtarget.isDarwin())
 240           O << ')';
 241         else
 242           O << "@l";
 243       }
 244     }
 245     void printcrbitm(const MachineInstr *MI, unsigned OpNo) {
 246       unsigned CCReg = MI->getOperand(OpNo).getReg();
 247       unsigned RegNo = enumRegToMachineReg(CCReg);
 248       O << (0x80 >> RegNo);
 249     }
 250     // The new addressing mode printers.
 251     void printMemRegImm(const MachineInstr *MI, unsigned OpNo) {
 252       printSymbolLo(MI, OpNo);
 253       O << '(';
 254       if (MI->getOperand(OpNo+1).isReg() &&
 255           MI->getOperand(OpNo+1).getReg() == PPC::R0)
 256         O << "0";
 257       else
 258         printOperand(MI, OpNo+1);
 259       O << ')';
 260     }
 261     void printMemRegImmShifted(const MachineInstr *MI, unsigned OpNo) {
 262       if (MI->getOperand(OpNo).isImm())
 263         printS16X4ImmOperand(MI, OpNo);
 264       else
 265         printSymbolLo(MI, OpNo);
 266       O << '(';
 267       if (MI->getOperand(OpNo+1).isReg() &&
 268           MI->getOperand(OpNo+1).getReg() == PPC::R0)
 269         O << "0";
 270       else
 271         printOperand(MI, OpNo+1);
 272       O << ')';
 273     }
 274
 275     void printMemRegReg(const MachineInstr *MI, unsigned OpNo) {
 276       // When used as the base register, r0 reads constant zero rather than
 277       // the value contained in the register.  For this reason, the darwin
 278       // assembler requires that we print r0 as 0 (no r) when used as the base.
 279       const MachineOperand &MO = MI->getOperand(OpNo);
 280       printRegister(MO, true);
 281       O << ", ";
 282       printOperand(MI, OpNo+1);
 283     }
 284
 285     void printPredicateOperand(const MachineInstr *MI, unsigned OpNo,
 286                                const char *Modifier);
 287
 288     virtual bool runOnMachineFunction(MachineFunction &F) = 0;
 289     virtual bool doFinalization(Module &M) = 0;
 290
 291     virtual void EmitExternalGlobal(const GlobalVariable *GV);
 292   };
 293
 294   /// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux
 295   class VISIBILITY_HIDDEN PPCLinuxAsmPrinter : public PPCAsmPrinter {
 296   public:
 297     explicit PPCLinuxAsmPrinter(raw_ostream &O, PPCTargetMachine &TM,
 298                                 const TargetAsmInfo *T, bool V)
 299       : PPCAsmPrinter(O, TM, T, V){}
 300
 301     virtual const char *getPassName() const {
 302       return "Linux PPC Assembly Printer";
 303     }
 304
 305     bool runOnMachineFunction(MachineFunction &F);
 306     bool doFinalization(Module &M);
 307
 308     void getAnalysisUsage(AnalysisUsage &AU) const {
 309       AU.setPreservesAll();
 310       AU.addRequired<MachineModuleInfo>();
 311       AU.addRequired<DwarfWriter>();
 312       PPCAsmPrinter::getAnalysisUsage(AU);
 313     }
 314
 315     void printModuleLevelGV(const GlobalVariable* GVar);
 316   };
 317
 318   /// PPCDarwinAsmPrinter - PowerPC assembly printer, customized for Darwin/Mac
 319   /// OS X
 320   class VISIBILITY_HIDDEN PPCDarwinAsmPrinter : public PPCAsmPrinter {
 321     raw_ostream &OS;
 322   public:
 323     explicit PPCDarwinAsmPrinter(raw_ostream &O, PPCTargetMachine &TM,
 324                                  const TargetAsmInfo *T, bool V)
 325       : PPCAsmPrinter(O, TM, T, V), OS(O) {}
 326
 327     virtual const char *getPassName() const {
 328       return "Darwin PPC Assembly Printer";
 329     }
 330
 331     bool runOnMachineFunction(MachineFunction &F);
 332     bool doInitialization(Module &M);
 333     bool doFinalization(Module &M);
 334
 335     void getAnalysisUsage(AnalysisUsage &AU) const {
 336       AU.setPreservesAll();
 337       AU.addRequired<MachineModuleInfo>();
 338       AU.addRequired<DwarfWriter>();
 339       PPCAsmPrinter::getAnalysisUsage(AU);
 340     }
 341
 342     void printModuleLevelGV(const GlobalVariable* GVar);
 343   };
 344 } // end of anonymous namespace
 345
 346 // Include the auto-generated portion of the assembly writer
 347 #include "PPCGenAsmWriter.inc"
 348
 349 void PPCAsmPrinter::printOp(const MachineOperand &MO) {
 350   switch (MO.getType()) {
 351   case MachineOperand::MO_Immediate:
 352     LLVM_UNREACHABLE("printOp() does not handle immediate values");
 353
 354   case MachineOperand::MO_MachineBasicBlock:
 355     printBasicBlockLabel(MO.getMBB());
 356     return;
 357   case MachineOperand::MO_JumpTableIndex:
 358     O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 359       << '_' << MO.getIndex();
 360     // FIXME: PIC relocation model
 361     return;
 362   case MachineOperand::MO_ConstantPoolIndex:
 363     O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber()
 364       << '_' << MO.getIndex();
 365     return;
 366   case MachineOperand::MO_ExternalSymbol:
 367     // Computing the address of an external symbol, not calling it.
 368     if (TM.getRelocationModel() != Reloc::Static) {
 369       std::string Name(TAI->getGlobalPrefix()); Name += MO.getSymbolName();
 370       GVStubs.insert(Name);
 371       printSuffixedName(Name, "$non_lazy_ptr");
 372       return;
 373     }
 374     O << TAI->getGlobalPrefix() << MO.getSymbolName();
 375     return;
 376   case MachineOperand::MO_GlobalAddress: {
 377     // Computing the address of a global symbol, not calling it.
 378     GlobalValue *GV = MO.getGlobal();
 379     std::string Name = Mang->getValueName(GV);
 380
 381     // External or weakly linked global variables need non-lazily-resolved stubs
 382     if (TM.getRelocationModel() != Reloc::Static) {
 383       if (GV->isDeclaration() || GV->isWeakForLinker()) {
 384         if (GV->hasHiddenVisibility()) {
 385           if (GV->isDeclaration() || GV->hasCommonLinkage() ||
 386               GV->hasAvailableExternallyLinkage()) {
 387             HiddenGVStubs.insert(Name);
 388             printSuffixedName(Name, "$non_lazy_ptr");
 389           } else {
 390             O << Name;
 391           }
 392         } else {
 393           GVStubs.insert(Name);
 394           printSuffixedName(Name, "$non_lazy_ptr");
 395         }
 396         return;
 397       }
 398     }
 399     O << Name;
 400
 401     printOffset(MO.getOffset());
 402     return;
 403   }
 404
 405   default:
 406     O << "<unknown operand type: " << MO.getType() << ">";
 407     return;
 408   }
 409 }
 410
 411 /// EmitExternalGlobal - In this case we need to use the indirect symbol.
 412 ///
 413 void PPCAsmPrinter::EmitExternalGlobal(const GlobalVariable *GV) {
 414   std::string Name;
 415   getGlobalLinkName(GV, Name);
 416   if (TM.getRelocationModel() != Reloc::Static) {
 417     if (GV->hasHiddenVisibility())
 418       HiddenGVStubs.insert(Name);
 419     else
 420       GVStubs.insert(Name);
 421     printSuffixedName(Name, "$non_lazy_ptr");
 422     return;
 423   }
 424   O << Name;
 425 }
 426
 427 /// PrintAsmOperand - Print out an operand for an inline asm expression.
 428 ///
 429 bool PPCAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
 430                                     unsigned AsmVariant,
 431                                     const char *ExtraCode) {
 432   // Does this asm operand have a single letter operand modifier?
 433   if (ExtraCode && ExtraCode[0]) {
 434     if (ExtraCode[1] != 0) return true; // Unknown modifier.
 435
 436     switch (ExtraCode[0]) {
 437     default: return true;  // Unknown modifier.
 438     case 'c': // Don't print "$" before a global var name or constant.
 439       // PPC never has a prefix.
 440       printOperand(MI, OpNo);
 441       return false;
 442     case 'L': // Write second word of DImode reference.
 443       // Verify that this operand has two consecutive registers.
 444       if (!MI->getOperand(OpNo).isReg() ||
 445           OpNo+1 == MI->getNumOperands() ||
 446           !MI->getOperand(OpNo+1).isReg())
 447         return true;
 448       ++OpNo;   // Return the high-part.
 449       break;
 450     case 'I':
 451       // Write 'i' if an integer constant, otherwise nothing.  Used to print
 452       // addi vs add, etc.
 453       if (MI->getOperand(OpNo).isImm())
 454         O << "i";
 455       return false;
 456     }
 457   }
 458
 459   printOperand(MI, OpNo);
 460   return false;
 461 }
 462
 463 bool PPCAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
 464                                           unsigned AsmVariant,
 465                                           const char *ExtraCode) {
 466   if (ExtraCode && ExtraCode[0])
 467     return true; // Unknown modifier.
 468   if (MI->getOperand(OpNo).isReg())
 469     printMemRegReg(MI, OpNo);
 470   else
 471     printMemRegImm(MI, OpNo);
 472   return false;
 473 }
 474
 475 void PPCAsmPrinter::printPredicateOperand(const MachineInstr *MI, unsigned OpNo,
 476                                           const char *Modifier) {
 477   assert(Modifier && "Must specify 'cc' or 'reg' as predicate op modifier!");
 478   unsigned Code = MI->getOperand(OpNo).getImm();
 479   if (!strcmp(Modifier, "cc")) {
 480     switch ((PPC::Predicate)Code) {
 481     case PPC::PRED_ALWAYS: return; // Don't print anything for always.
 482     case PPC::PRED_LT: O << "lt"; return;
 483     case PPC::PRED_LE: O << "le"; return;
 484     case PPC::PRED_EQ: O << "eq"; return;
 485     case PPC::PRED_GE: O << "ge"; return;
 486     case PPC::PRED_GT: O << "gt"; return;
 487     case PPC::PRED_NE: O << "ne"; return;
 488     case PPC::PRED_UN: O << "un"; return;
 489     case PPC::PRED_NU: O << "nu"; return;
 490     }
 491
 492   } else {
 493     assert(!strcmp(Modifier, "reg") &&
 494            "Need to specify 'cc' or 'reg' as predicate op modifier!");
 495     // Don't print the register for 'always'.
 496     if (Code == PPC::PRED_ALWAYS) return;
 497     printOperand(MI, OpNo+1);
 498   }
 499 }
 500
 501
 502 /// printMachineInstruction -- Print out a single PowerPC MI in Darwin syntax to
 503 /// the current output stream.
 504 ///
 505 void PPCAsmPrinter::printMachineInstruction(const MachineInstr *MI) {
 506   ++EmittedInsts;
 507
 508   // Check for slwi/srwi mnemonics.
 509   if (MI->getOpcode() == PPC::RLWINM) {
 510     bool FoundMnemonic = false;
 511     unsigned char SH = MI->getOperand(2).getImm();
 512     unsigned char MB = MI->getOperand(3).getImm();
 513     unsigned char ME = MI->getOperand(4).getImm();
 514     if (SH <= 31 && MB == 0 && ME == (31-SH)) {
 515       O << "\tslwi "; FoundMnemonic = true;
 516     }
 517     if (SH <= 31 && MB == (32-SH) && ME == 31) {
 518       O << "\tsrwi "; FoundMnemonic = true;
 519       SH = 32-SH;
 520     }
 521     if (FoundMnemonic) {
 522       printOperand(MI, 0);
 523       O << ", ";
 524       printOperand(MI, 1);
 525       O << ", " << (unsigned int)SH << '\n';
 526       return;
 527     }
 528   } else if (MI->getOpcode() == PPC::OR || MI->getOpcode() == PPC::OR8) {
 529     if (MI->getOperand(1).getReg() == MI->getOperand(2).getReg()) {
 530       O << "\tmr ";
 531       printOperand(MI, 0);
 532       O << ", ";
 533       printOperand(MI, 1);
 534       O << '\n';
 535       return;
 536     }
 537   } else if (MI->getOpcode() == PPC::RLDICR) {
 538     unsigned char SH = MI->getOperand(2).getImm();
 539     unsigned char ME = MI->getOperand(3).getImm();
 540     // rldicr RA, RS, SH, 63-SH == sldi RA, RS, SH
 541     if (63-SH == ME) {
 542       O << "\tsldi ";
 543       printOperand(MI, 0);
 544       O << ", ";
 545       printOperand(MI, 1);
 546       O << ", " << (unsigned int)SH << '\n';
 547       return;
 548     }
 549   }
 550
 551   if (printInstruction(MI))
 552     return; // Printer was automatically generated
 553
 554   LLVM_UNREACHABLE("Unhandled instruction in asm writer!");
 555 }
 556
 557 /// runOnMachineFunction - This uses the printMachineInstruction()
 558 /// method to print assembly for each instruction.
 559 ///
 560 bool PPCLinuxAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
 561   this->MF = &MF;
 562
 563   SetupMachineFunction(MF);
 564   O << "\n\n";
 565
 566   // Print out constants referenced by the function
 567   EmitConstantPool(MF.getConstantPool());
 568
 569   // Print out labels for the function.
 570   const Function *F = MF.getFunction();
 571   SwitchToSection(TAI->SectionForGlobal(F));
 572
 573   switch (F->getLinkage()) {
 574   default: assert(0 && "Unknown linkage type!");
 575   case Function::PrivateLinkage:
 576   case Function::InternalLinkage:  // Symbols default to internal.
 577     break;
 578   case Function::ExternalLinkage:
 579     O << "\t.global\t" << CurrentFnName << '\n'
 580       << "\t.type\t" << CurrentFnName << ", @function\n";
 581     break;
 582   case Function::WeakAnyLinkage:
 583   case Function::WeakODRLinkage:
 584   case Function::LinkOnceAnyLinkage:
 585   case Function::LinkOnceODRLinkage:
 586     O << "\t.global\t" << CurrentFnName << '\n';
 587     O << "\t.weak\t" << CurrentFnName << '\n';
 588     break;
 589   }
 590
 591   printVisibility(CurrentFnName, F->getVisibility());
 592
 593   EmitAlignment(MF.getAlignment(), F);
 594   O << CurrentFnName << ":\n";
 595
 596   // Emit pre-function debug information.
 597   DW->BeginFunction(&MF);
 598
 599   // Print out code for the function.
 600   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 601        I != E; ++I) {
 602     // Print a label for the basic block.
 603     if (I != MF.begin()) {
 604       printBasicBlockLabel(I, true, true);
 605       O << '\n';
 606     }
 607     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
 608          II != E; ++II) {
 609       // Print the assembly for the instruction.
 610       printMachineInstruction(II);
 611     }
 612   }
 613
 614   O << "\t.size\t" << CurrentFnName << ",.-" << CurrentFnName << '\n';
 615
 616   // Print out jump tables referenced by the function.
 617   EmitJumpTableInfo(MF.getJumpTableInfo(), MF);
 618
 619   SwitchToSection(TAI->SectionForGlobal(F));
 620
 621   // Emit post-function debug information.
 622   DW->EndFunction(&MF);
 623
 624   O.flush();
 625
 626   // We didn't modify anything.
 627   return false;
 628 }
 629
 630 /// PrintUnmangledNameSafely - Print out the printable characters in the name.
 631 /// Don't print things like \\n or \\0.
 632 static void PrintUnmangledNameSafely(const Value *V, raw_ostream &OS) {
 633   for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
 634        Name != E; ++Name)
 635     if (isprint(*Name))
 636       OS << *Name;
 637 }
 638
 639 void PPCLinuxAsmPrinter::printModuleLevelGV(const GlobalVariable* GVar) {
 640   const TargetData *TD = TM.getTargetData();
 641
 642   if (!GVar->hasInitializer())
 643     return;   // External global require no code
 644
 645   // Check to see if this is a special global used by LLVM, if so, emit it.
 646   if (EmitSpecialLLVMGlobal(GVar))
 647     return;
 648
 649   std::string name = Mang->getValueName(GVar);
 650
 651   printVisibility(name, GVar->getVisibility());
 652
 653   Constant *C = GVar->getInitializer();
 654   if (isa<MDNode>(C) || isa<MDString>(C))
 655     return;
 656   const Type *Type = C->getType();
 657   unsigned Size = TD->getTypeAllocSize(Type);
 658   unsigned Align = TD->getPreferredAlignmentLog(GVar);
 659
 660   SwitchToSection(TAI->SectionForGlobal(GVar));
 661
 662   if (C->isNullValue() && /* FIXME: Verify correct */
 663       !GVar->hasSection() &&
 664       (GVar->hasLocalLinkage() || GVar->hasExternalLinkage() ||
 665        GVar->isWeakForLinker())) {
 666       if (Size == 0) Size = 1;   // .comm Foo, 0 is undefined, avoid it.
 667
 668       if (GVar->hasExternalLinkage()) {
 669         O << "\t.global " << name << '\n';
 670         O << "\t.type " << name << ", @object\n";
 671         O << name << ":\n";
 672         O << "\t.zero " << Size << '\n';
 673       } else if (GVar->hasLocalLinkage()) {
 674         O << TAI->getLCOMMDirective() << name << ',' << Size;
 675       } else {
 676         O << ".comm " << name << ',' << Size;
 677       }
 678       if (VerboseAsm) {
 679         O << "\t\t" << TAI->getCommentString() << " '";
 680         PrintUnmangledNameSafely(GVar, O);
 681         O << "'";
 682       }
 683       O << '\n';
 684       return;
 685   }
 686
 687   switch (GVar->getLinkage()) {
 688    case GlobalValue::LinkOnceAnyLinkage:
 689    case GlobalValue::LinkOnceODRLinkage:
 690    case GlobalValue::WeakAnyLinkage:
 691    case GlobalValue::WeakODRLinkage:
 692    case GlobalValue::CommonLinkage:
 693     O << "\t.global " << name << '\n'
 694       << "\t.type " << name << ", @object\n"
 695       << "\t.weak " << name << '\n';
 696     break;
 697    case GlobalValue::AppendingLinkage:
 698     // FIXME: appending linkage variables should go into a section of
 699     // their name or something.  For now, just emit them as external.
 700    case GlobalValue::ExternalLinkage:
 701     // If external or appending, declare as a global symbol
 702     O << "\t.global " << name << '\n'
 703       << "\t.type " << name << ", @object\n";
 704     // FALL THROUGH
 705    case GlobalValue::InternalLinkage:
 706    case GlobalValue::PrivateLinkage:
 707     break;
 708    default:
 709     LLVM_UNREACHABLE("Unknown linkage type!");
 710   }
 711
 712   EmitAlignment(Align, GVar);
 713   O << name << ":";
 714   if (VerboseAsm) {
 715     O << "\t\t\t\t" << TAI->getCommentString() << " '";
 716     PrintUnmangledNameSafely(GVar, O);
 717     O << "'";
 718   }
 719   O << '\n';
 720
 721   EmitGlobalConstant(C);
 722   O << '\n';
 723 }
 724
 725 bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
 726   // Print out module-level global variables here.
 727   for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
 728        I != E; ++I)
 729     printModuleLevelGV(I);
 730
 731   return AsmPrinter::doFinalization(M);
 732 }
 733
 734 /// runOnMachineFunction - This uses the printMachineInstruction()
 735 /// method to print assembly for each instruction.
 736 ///
 737 bool PPCDarwinAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
 738   this->MF = &MF;
 739
 740   SetupMachineFunction(MF);
 741   O << "\n\n";
 742
 743   // Print out constants referenced by the function
 744   EmitConstantPool(MF.getConstantPool());
 745
 746   // Print out labels for the function.
 747   const Function *F = MF.getFunction();
 748   SwitchToSection(TAI->SectionForGlobal(F));
 749
 750   switch (F->getLinkage()) {
 751   default: assert(0 && "Unknown linkage type!");
 752   case Function::PrivateLinkage:
 753   case Function::InternalLinkage:  // Symbols default to internal.
 754     break;
 755   case Function::ExternalLinkage:
 756     O << "\t.globl\t" << CurrentFnName << '\n';
 757     break;
 758   case Function::WeakAnyLinkage:
 759   case Function::WeakODRLinkage:
 760   case Function::LinkOnceAnyLinkage:
 761   case Function::LinkOnceODRLinkage:
 762     O << "\t.globl\t" << CurrentFnName << '\n';
 763     O << "\t.weak_definition\t" << CurrentFnName << '\n';
 764     break;
 765   }
 766
 767   printVisibility(CurrentFnName, F->getVisibility());
 768
 769   EmitAlignment(MF.getAlignment(), F);
 770   O << CurrentFnName << ":\n";
 771
 772   // Emit pre-function debug information.
 773   DW->BeginFunction(&MF);
 774
 775   // If the function is empty, then we need to emit *something*. Otherwise, the
 776   // function's label might be associated with something that it wasn't meant to
 777   // be associated with. We emit a noop in this situation.
 778   MachineFunction::iterator I = MF.begin();
 779
 780   if (++I == MF.end() && MF.front().empty())
 781     O << "\tnop\n";
 782
 783   // Print out code for the function.
 784   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 785        I != E; ++I) {
 786     // Print a label for the basic block.
 787     if (I != MF.begin()) {
 788       printBasicBlockLabel(I, true, true, VerboseAsm);
 789       O << '\n';
 790     }
 791     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
 792          II != IE; ++II) {
 793       // Print the assembly for the instruction.
 794       printMachineInstruction(II);
 795     }
 796   }
 797
 798   // Print out jump tables referenced by the function.
 799   EmitJumpTableInfo(MF.getJumpTableInfo(), MF);
 800
 801   // Emit post-function debug information.
 802   DW->EndFunction(&MF);
 803
 804   // We didn't modify anything.
 805   return false;
 806 }
 807
 808
 809 bool PPCDarwinAsmPrinter::doInitialization(Module &M) {
 810   static const char *const CPUDirectives[] = {
 811     "",
 812     "ppc",
 813     "ppc601",
 814     "ppc602",
 815     "ppc603",
 816     "ppc7400",
 817     "ppc750",
 818     "ppc970",
 819     "ppc64"
 820   };
 821
 822   unsigned Directive = Subtarget.getDarwinDirective();
 823   if (Subtarget.isGigaProcessor() && Directive < PPC::DIR_970)
 824     Directive = PPC::DIR_970;
 825   if (Subtarget.hasAltivec() && Directive < PPC::DIR_7400)
 826     Directive = PPC::DIR_7400;
 827   if (Subtarget.isPPC64() && Directive < PPC::DIR_970)
 828     Directive = PPC::DIR_64;
 829   assert(Directive <= PPC::DIR_64 && "Directive out of range.");
 830   O << "\t.machine " << CPUDirectives[Directive] << '\n';
 831
 832   bool Result = AsmPrinter::doInitialization(M);
 833   assert(MMI);
 834
 835   // Prime text sections so they are adjacent.  This reduces the likelihood a
 836   // large data or debug section causes a branch to exceed 16M limit.
 837   SwitchToTextSection("\t.section __TEXT,__textcoal_nt,coalesced,"
 838                       "pure_instructions");
 839   if (TM.getRelocationModel() == Reloc::PIC_) {
 840     SwitchToTextSection("\t.section __TEXT,__picsymbolstub1,symbol_stubs,"
 841                           "pure_instructions,32");
 842   } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) {
 843     SwitchToTextSection("\t.section __TEXT,__symbol_stub1,symbol_stubs,"
 844                         "pure_instructions,16");
 845   }
 846   SwitchToSection(TAI->getTextSection());
 847
 848   return Result;
 849 }
 850
 851 void PPCDarwinAsmPrinter::printModuleLevelGV(const GlobalVariable* GVar) {
 852   const TargetData *TD = TM.getTargetData();
 853
 854   if (!GVar->hasInitializer())
 855     return;   // External global require no code
 856
 857   // Check to see if this is a special global used by LLVM, if so, emit it.
 858   if (EmitSpecialLLVMGlobal(GVar)) {
 859     if (TM.getRelocationModel() == Reloc::Static) {
 860       if (GVar->getName() == "llvm.global_ctors")
 861         O << ".reference .constructors_used\n";
 862       else if (GVar->getName() == "llvm.global_dtors")
 863         O << ".reference .destructors_used\n";
 864     }
 865     return;
 866   }
 867
 868   std::string name = Mang->getValueName(GVar);
 869
 870   printVisibility(name, GVar->getVisibility());
 871
 872   Constant *C = GVar->getInitializer();
 873   const Type *Type = C->getType();
 874   unsigned Size = TD->getTypeAllocSize(Type);
 875   unsigned Align = TD->getPreferredAlignmentLog(GVar);
 876
 877   SwitchToSection(TAI->SectionForGlobal(GVar));
 878
 879   if (C->isNullValue() && /* FIXME: Verify correct */
 880       !GVar->hasSection() &&
 881       (GVar->hasLocalLinkage() || GVar->hasExternalLinkage() ||
 882        GVar->isWeakForLinker()) &&
 883       TAI->SectionKindForGlobal(GVar) != SectionKind::RODataMergeStr) {
 884     if (Size == 0) Size = 1;   // .comm Foo, 0 is undefined, avoid it.
 885
 886     if (GVar->hasExternalLinkage()) {
 887       O << "\t.globl " << name << '\n';
 888       O << "\t.zerofill __DATA, __common, " << name << ", "
 889         << Size << ", " << Align;
 890     } else if (GVar->hasLocalLinkage()) {
 891       O << TAI->getLCOMMDirective() << name << ',' << Size << ',' << Align;
 892     } else if (!GVar->hasCommonLinkage()) {
 893       O << "\t.globl " << name << '\n'
 894         << TAI->getWeakDefDirective() << name << '\n';
 895       EmitAlignment(Align, GVar);
 896       O << name << ":";
 897       if (VerboseAsm) {
 898         O << "\t\t\t\t" << TAI->getCommentString() << " ";
 899         PrintUnmangledNameSafely(GVar, O);
 900       }
 901       O << '\n';
 902       EmitGlobalConstant(C);
 903       return;
 904     } else {
 905       O << ".comm " << name << ',' << Size;
 906       // Darwin 9 and above support aligned common data.
 907       if (Subtarget.isDarwin9())
 908         O << ',' << Align;
 909     }
 910     if (VerboseAsm) {
 911       O << "\t\t" << TAI->getCommentString() << " '";
 912       PrintUnmangledNameSafely(GVar, O);
 913       O << "'";
 914     }
 915     O << '\n';
 916     return;
 917   }
 918
 919   switch (GVar->getLinkage()) {
 920    case GlobalValue::LinkOnceAnyLinkage:
 921    case GlobalValue::LinkOnceODRLinkage:
 922    case GlobalValue::WeakAnyLinkage:
 923    case GlobalValue::WeakODRLinkage:
 924    case GlobalValue::CommonLinkage:
 925     O << "\t.globl " << name << '\n'
 926       << "\t.weak_definition " << name << '\n';
 927     break;
 928    case GlobalValue::AppendingLinkage:
 929     // FIXME: appending linkage variables should go into a section of
 930     // their name or something.  For now, just emit them as external.
 931    case GlobalValue::ExternalLinkage:
 932     // If external or appending, declare as a global symbol
 933     O << "\t.globl " << name << '\n';
 934     // FALL THROUGH
 935    case GlobalValue::InternalLinkage:
 936    case GlobalValue::PrivateLinkage:
 937     break;
 938    default:
 939     LLVM_UNREACHABLE("Unknown linkage type!");
 940   }
 941
 942   EmitAlignment(Align, GVar);
 943   O << name << ":";
 944   if (VerboseAsm) {
 945     O << "\t\t\t\t" << TAI->getCommentString() << " '";
 946     PrintUnmangledNameSafely(GVar, O);
 947     O << "'";
 948   }
 949   O << '\n';
 950
 951   EmitGlobalConstant(C);
 952   O << '\n';
 953 }
 954
 955 bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
 956   const TargetData *TD = TM.getTargetData();
 957
 958   // Print out module-level global variables here.
 959   for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
 960        I != E; ++I)
 961     printModuleLevelGV(I);
 962
 963   bool isPPC64 = TD->getPointerSizeInBits() == 64;
 964
 965   // Output stubs for dynamically-linked functions
 966   if (TM.getRelocationModel() == Reloc::PIC_) {
 967     for (StringSet<>::iterator i = FnStubs.begin(), e = FnStubs.end();
 968          i != e; ++i) {
 969       SwitchToTextSection("\t.section __TEXT,__picsymbolstub1,symbol_stubs,"
 970                           "pure_instructions,32");
 971       EmitAlignment(4);
 972       const char *p = i->getKeyData();
 973       bool hasQuote = p[0]=='\"';
 974       printSuffixedName(p, "$stub");
 975       O << ":\n";
 976       O << "\t.indirect_symbol " << p << '\n';
 977       O << "\tmflr r0\n";
 978       O << "\tbcl 20,31,";
 979       if (hasQuote)
 980         O << "\"L0$" << &p[1];
 981       else
 982         O << "L0$" << p;
 983       O << '\n';
 984       if (hasQuote)
 985         O << "\"L0$" << &p[1];
 986       else
 987         O << "L0$" << p;
 988       O << ":\n";
 989       O << "\tmflr r11\n";
 990       O << "\taddis r11,r11,ha16(";
 991       printSuffixedName(p, "$lazy_ptr");
 992       O << "-";
 993       if (hasQuote)
 994         O << "\"L0$" << &p[1];
 995       else
 996         O << "L0$" << p;
 997       O << ")\n";
 998       O << "\tmtlr r0\n";
 999       if (isPPC64)
1000         O << "\tldu r12,lo16(";
1001       else
1002         O << "\tlwzu r12,lo16(";
1003       printSuffixedName(p, "$lazy_ptr");
1004       O << "-";
1005       if (hasQuote)
1006         O << "\"L0$" << &p[1];
1007       else
1008         O << "L0$" << p;
1009       O << ")(r11)\n";
1010       O << "\tmtctr r12\n";
1011       O << "\tbctr\n";
1012       SwitchToDataSection(".lazy_symbol_pointer");
1013       printSuffixedName(p, "$lazy_ptr");
1014       O << ":\n";
1015       O << "\t.indirect_symbol " << p << '\n';
1016       if (isPPC64)
1017         O << "\t.quad dyld_stub_binding_helper\n";
1018       else
1019         O << "\t.long dyld_stub_binding_helper\n";
1020     }
1021   } else {
1022     for (StringSet<>::iterator i = FnStubs.begin(), e = FnStubs.end();
1023          i != e; ++i) {
1024       SwitchToTextSection("\t.section __TEXT,__symbol_stub1,symbol_stubs,"
1025                           "pure_instructions,16");
1026       EmitAlignment(4);
1027       const char *p = i->getKeyData();
1028       printSuffixedName(p, "$stub");
1029       O << ":\n";
1030       O << "\t.indirect_symbol " << p << '\n';
1031       O << "\tlis r11,ha16(";
1032       printSuffixedName(p, "$lazy_ptr");
1033       O << ")\n";
1034       if (isPPC64)
1035         O << "\tldu r12,lo16(";
1036       else
1037         O << "\tlwzu r12,lo16(";
1038       printSuffixedName(p, "$lazy_ptr");
1039       O << ")(r11)\n";
1040       O << "\tmtctr r12\n";
1041       O << "\tbctr\n";
1042       SwitchToDataSection(".lazy_symbol_pointer");
1043       printSuffixedName(p, "$lazy_ptr");
1044       O << ":\n";
1045       O << "\t.indirect_symbol " << p << '\n';
1046       if (isPPC64)
1047         O << "\t.quad dyld_stub_binding_helper\n";
1048       else
1049         O << "\t.long dyld_stub_binding_helper\n";
1050     }
1051   }
1052
1053   O << '\n';
1054
1055   if (TAI->doesSupportExceptionHandling() && MMI) {
1056     // Add the (possibly multiple) personalities to the set of global values.
1057     // Only referenced functions get into the Personalities list.
1058     const std::vector<Function *> &Personalities = MMI->getPersonalities();
1059     for (std::vector<Function *>::const_iterator I = Personalities.begin(),
1060            E = Personalities.end(); I != E; ++I)
1061       if (*I) GVStubs.insert("_" + (*I)->getName());
1062   }
1063
1064   // Output stubs for external and common global variables.
1065   if (!GVStubs.empty()) {
1066     SwitchToDataSection(".non_lazy_symbol_pointer");
1067     for (StringSet<>::iterator i = GVStubs.begin(), e = GVStubs.end();
1068          i != e; ++i) {
1069       std::string p = i->getKeyData();
1070       printSuffixedName(p, "$non_lazy_ptr");
1071       O << ":\n";
1072       O << "\t.indirect_symbol " << p << '\n';
1073       if (isPPC64)
1074         O << "\t.quad\t0\n";
1075       else
1076         O << "\t.long\t0\n";
1077     }
1078   }
1079
1080   if (!HiddenGVStubs.empty()) {
1081     SwitchToSection(TAI->getDataSection());
1082     for (StringSet<>::iterator i = HiddenGVStubs.begin(), e = HiddenGVStubs.end();
1083          i != e; ++i) {
1084       std::string p = i->getKeyData();
1085       EmitAlignment(isPPC64 ? 3 : 2);
1086       printSuffixedName(p, "$non_lazy_ptr");
1087       O << ":\n";
1088       if (isPPC64)
1089         O << "\t.quad\t";
1090       else
1091         O << "\t.long\t";
1092       O << p << '\n';
1093     }
1094   }
1095
1096   // Funny Darwin hack: This flag tells the linker that no global symbols
1097   // contain code that falls through to other global symbols (e.g. the obvious
1098   // implementation of multiple entry points).  If this doesn't occur, the
1099   // linker can safely perform dead code stripping.  Since LLVM never generates
1100   // code that does this, it is always safe to set.
1101   O << "\t.subsections_via_symbols\n";
1102
1103   return AsmPrinter::doFinalization(M);
1104 }
1105
1106
1107
1108 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
1109 /// for a MachineFunction to the given output stream, in a format that the
1110 /// Darwin assembler can deal with.
1111 ///
1112 FunctionPass *llvm::createPPCAsmPrinterPass(raw_ostream &o,
1113                                             PPCTargetMachine &tm,
1114                                             bool verbose) {
1115   const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();
1116
1117   if (Subtarget->isDarwin()) {
1118     return new PPCDarwinAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose);
1119   } else {
1120     return new PPCLinuxAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose);
1121   }
1122 }
1123
1124 namespace {
1125   static struct Register {
1126     Register() {
1127       PPCTargetMachine::registerAsmPrinter(createPPCAsmPrinterPass);
1128     }
1129   } Registrator;
1130 }
1131
1132 extern "C" int PowerPCAsmPrinterForceLink;
1133 int PowerPCAsmPrinterForceLink = 0;
1134
1135 // Force static initialization.
1136 extern "C" void LLVMInitializePowerPCAsmPrinter() { }