lib/Target/PowerPC/PPCAsmPrinter.cpp

   1 //===-- Printer.cpp - Convert LLVM code to PowerPC assembly ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source 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' and `lli -print-machineinstrs'.
  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 "PowerPC.h"
  21 #include "PowerPCInstrInfo.h"
  22 #include "PowerPCTargetMachine.h"
  23 #include "llvm/Constants.h"
  24 #include "llvm/DerivedTypes.h"
  25 #include "llvm/Module.h"
  26 #include "llvm/Assembly/Writer.h"
  27 #include "llvm/CodeGen/MachineConstantPool.h"
  28 #include "llvm/CodeGen/MachineFunctionPass.h"
  29 #include "llvm/CodeGen/MachineInstr.h"
  30 #include "llvm/Target/TargetMachine.h"
  31 #include "llvm/Support/Mangler.h"
  32 #include "Support/CommandLine.h"
  33 #include "Support/Debug.h"
  34 #include "Support/Statistic.h"
  35 #include "Support/StringExtras.h"
  36 #include <set>
  37
  38 namespace llvm {
  39
  40 namespace {
  41   Statistic<> EmittedInsts("asm-printer", "Number of machine instrs printed");
  42
  43   struct Printer : public MachineFunctionPass {
  44     /// Output stream on which we're printing assembly code.
  45     ///
  46     std::ostream &O;
  47
  48     /// Target machine description which we query for reg. names, data
  49     /// layout, etc.
  50     ///
  51     PowerPCTargetMachine &TM;
  52
  53     /// Name-mangler for global names.
  54     ///
  55     Mangler *Mang;
  56     std::set<std::string> FnStubs, GVStubs, LinkOnceStubs;
  57     std::set<std::string> Strings;
  58
  59     Printer(std::ostream &o, TargetMachine &tm) : O(o),
  60       TM(reinterpret_cast<PowerPCTargetMachine&>(tm)), LabelNumber(0) {}
  61
  62     /// Cache of mangled name for current function. This is
  63     /// recalculated at the beginning of each call to
  64     /// runOnMachineFunction().
  65     ///
  66     std::string CurrentFnName;
  67
  68     /// Unique incrementer for label values for referencing Global values.
  69     ///
  70     unsigned LabelNumber;
  71
  72     virtual const char *getPassName() const {
  73       return "PowerPC Assembly Printer";
  74     }
  75
  76     void printMachineInstruction(const MachineInstr *MI);
  77     void printOp(const MachineOperand &MO, bool elideOffsetKeyword = false);
  78     void printConstantPool(MachineConstantPool *MCP);
  79     bool runOnMachineFunction(MachineFunction &F);
  80     bool doInitialization(Module &M);
  81     bool doFinalization(Module &M);
  82     void emitGlobalConstant(const Constant* CV);
  83     void emitConstantValueOnly(const Constant *CV);
  84   };
  85 } // end of anonymous namespace
  86
  87 /// createPPCCodePrinterPass - Returns a pass that prints the PPC
  88 /// assembly code for a MachineFunction to the given output stream,
  89 /// using the given target machine description.  This should work
  90 /// regardless of whether the function is in SSA form.
  91 ///
  92 FunctionPass *createPPCCodePrinterPass(std::ostream &o,TargetMachine &tm) {
  93   return new Printer(o, tm);
  94 }
  95
  96 /// isStringCompatible - Can we treat the specified array as a string?
  97 /// Only if it is an array of ubytes or non-negative sbytes.
  98 ///
  99 static bool isStringCompatible(const ConstantArray *CVA) {
 100   const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
 101   if (ETy == Type::UByteTy) return true;
 102   if (ETy != Type::SByteTy) return false;
 103
 104   for (unsigned i = 0; i < CVA->getNumOperands(); ++i)
 105     if (cast<ConstantSInt>(CVA->getOperand(i))->getValue() < 0)
 106       return false;
 107
 108   return true;
 109 }
 110
 111 /// toOctal - Convert the low order bits of X into an octal digit.
 112 ///
 113 static inline char toOctal(int X) {
 114   return (X&7)+'0';
 115 }
 116
 117 /// getAsCString - Return the specified array as a C compatible
 118 /// string, only if the predicate isStringCompatible is true.
 119 ///
 120 static void printAsCString(std::ostream &O, const ConstantArray *CVA) {
 121   assert(isStringCompatible(CVA) && "Array is not string compatible!");
 122
 123   O << "\"";
 124   for (unsigned i = 0; i < CVA->getNumOperands(); ++i) {
 125     unsigned char C = cast<ConstantInt>(CVA->getOperand(i))->getRawValue();
 126
 127     if (C == '"') {
 128       O << "\\\"";
 129     } else if (C == '\\') {
 130       O << "\\\\";
 131     } else if (isprint(C)) {
 132       O << C;
 133     } else {
 134       switch (C) {
 135       case '\b': O << "\\b"; break;
 136       case '\f': O << "\\f"; break;
 137       case '\n': O << "\\n"; break;
 138       case '\r': O << "\\r"; break;
 139       case '\t': O << "\\t"; break;
 140       default:
 141         O << '\\';
 142         O << toOctal(C >> 6);
 143         O << toOctal(C >> 3);
 144         O << toOctal(C >> 0);
 145         break;
 146       }
 147     }
 148   }
 149   O << "\"";
 150 }
 151
 152 // Print out the specified constant, without a storage class.  Only the
 153 // constants valid in constant expressions can occur here.
 154 void Printer::emitConstantValueOnly(const Constant *CV) {
 155   if (CV->isNullValue())
 156     O << "0";
 157   else if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
 158     assert(CB == ConstantBool::True);
 159     O << "1";
 160   } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV))
 161     O << CI->getValue();
 162   else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV))
 163     O << CI->getValue();
 164   else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV))
 165     // This is a constant address for a global variable or function.  Use the
 166     // name of the variable or function as the address value.
 167     O << Mang->getValueName(GV);
 168   else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
 169     const TargetData &TD = TM.getTargetData();
 170     switch (CE->getOpcode()) {
 171     case Instruction::GetElementPtr: {
 172       // generate a symbolic expression for the byte address
 173       const Constant *ptrVal = CE->getOperand(0);
 174       std::vector<Value*> idxVec(CE->op_begin()+1, CE->op_end());
 175       if (unsigned Offset = TD.getIndexedOffset(ptrVal->getType(), idxVec)) {
 176         O << "(";
 177         emitConstantValueOnly(ptrVal);
 178         O << ") + " << Offset;
 179       } else {
 180         emitConstantValueOnly(ptrVal);
 181       }
 182       break;
 183     }
 184     case Instruction::Cast: {
 185       // Support only non-converting or widening casts for now, that is, ones
 186       // that do not involve a change in value.  This assertion is really gross,
 187       // and may not even be a complete check.
 188       Constant *Op = CE->getOperand(0);
 189       const Type *OpTy = Op->getType(), *Ty = CE->getType();
 190
 191       // Remember, kids, pointers on x86 can be losslessly converted back and
 192       // forth into 32-bit or wider integers, regardless of signedness. :-P
 193       assert(((isa<PointerType>(OpTy)
 194                && (Ty == Type::LongTy || Ty == Type::ULongTy
 195                    || Ty == Type::IntTy || Ty == Type::UIntTy))
 196               || (isa<PointerType>(Ty)
 197                   && (OpTy == Type::LongTy || OpTy == Type::ULongTy
 198                       || OpTy == Type::IntTy || OpTy == Type::UIntTy))
 199               || (((TD.getTypeSize(Ty) >= TD.getTypeSize(OpTy))
 200                    && OpTy->isLosslesslyConvertibleTo(Ty))))
 201              && "FIXME: Don't yet support this kind of constant cast expr");
 202       O << "(";
 203       emitConstantValueOnly(Op);
 204       O << ")";
 205       break;
 206     }
 207     case Instruction::Add:
 208       O << "(";
 209       emitConstantValueOnly(CE->getOperand(0));
 210       O << ") + (";
 211       emitConstantValueOnly(CE->getOperand(1));
 212       O << ")";
 213       break;
 214     default:
 215       assert(0 && "Unsupported operator!");
 216     }
 217   } else {
 218     assert(0 && "Unknown constant value!");
 219   }
 220 }
 221
 222 // Print a constant value or values, with the appropriate storage class as a
 223 // prefix.
 224 void Printer::emitGlobalConstant(const Constant *CV) {
 225   const TargetData &TD = TM.getTargetData();
 226
 227   if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) {
 228     if (isStringCompatible(CVA)) {
 229       O << "\t.ascii ";
 230       printAsCString(O, CVA);
 231       O << "\n";
 232     } else { // Not a string.  Print the values in successive locations
 233       const std::vector<Use> &constValues = CVA->getValues();
 234       for (unsigned i=0; i < constValues.size(); i++)
 235         emitGlobalConstant(cast<Constant>(constValues[i].get()));
 236     }
 237     return;
 238   } else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) {
 239     // Print the fields in successive locations. Pad to align if needed!
 240     const StructLayout *cvsLayout = TD.getStructLayout(CVS->getType());
 241     const std::vector<Use>& constValues = CVS->getValues();
 242     unsigned sizeSoFar = 0;
 243     for (unsigned i=0, N = constValues.size(); i < N; i++) {
 244       const Constant* field = cast<Constant>(constValues[i].get());
 245
 246       // Check if padding is needed and insert one or more 0s.
 247       unsigned fieldSize = TD.getTypeSize(field->getType());
 248       unsigned padSize = ((i == N-1? cvsLayout->StructSize
 249                            : cvsLayout->MemberOffsets[i+1])
 250                           - cvsLayout->MemberOffsets[i]) - fieldSize;
 251       sizeSoFar += fieldSize + padSize;
 252
 253       // Now print the actual field value
 254       emitGlobalConstant(field);
 255
 256       // Insert the field padding unless it's zero bytes...
 257       if (padSize)
 258         O << "\t.space\t " << padSize << "\n";
 259     }
 260     assert(sizeSoFar == cvsLayout->StructSize &&
 261            "Layout of constant struct may be incorrect!");
 262     return;
 263   } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
 264     // FP Constants are printed as integer constants to avoid losing
 265     // precision...
 266     double Val = CFP->getValue();
 267     switch (CFP->getType()->getTypeID()) {
 268     default: assert(0 && "Unknown floating point type!");
 269     case Type::FloatTyID: {
 270       union FU {                            // Abide by C TBAA rules
 271         float FVal;
 272         unsigned UVal;
 273       } U;
 274       U.FVal = Val;
 275       O << ".long\t" << U.UVal << "\t; float " << Val << "\n";
 276       return;
 277     }
 278     case Type::DoubleTyID: {
 279       union DU {                            // Abide by C TBAA rules
 280         double FVal;
 281         uint64_t UVal;
 282         struct {
 283           uint32_t MSWord;
 284           uint32_t LSWord;
 285         } T;
 286       } U;
 287       U.FVal = Val;
 288
 289       O << ".long\t" << U.T.MSWord << "\t; double most significant word "
 290         << Val << "\n";
 291       O << ".long\t" << U.T.LSWord << "\t; double least significant word "
 292         << Val << "\n";
 293       return;
 294     }
 295     }
 296   } else if (CV->getType()->getPrimitiveSize() == 64) {
 297     if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
 298       union DU {                            // Abide by C TBAA rules
 299         int64_t UVal;
 300         struct {
 301           uint32_t MSWord;
 302           uint32_t LSWord;
 303         } T;
 304       } U;
 305       U.UVal = CI->getRawValue();
 306
 307       O << ".long\t" << U.T.MSWord << "\t; Double-word most significant word "
 308         << U.UVal << "\n";
 309       O << ".long\t" << U.T.LSWord << "\t; Double-word least significant word "
 310         << U.UVal << "\n";
 311       return;
 312     }
 313   }
 314
 315   const Type *type = CV->getType();
 316   O << "\t";
 317   switch (type->getTypeID()) {
 318   case Type::UByteTyID: case Type::SByteTyID:
 319     O << ".byte";
 320     break;
 321   case Type::UShortTyID: case Type::ShortTyID:
 322     O << ".short";
 323     break;
 324   case Type::BoolTyID:
 325   case Type::PointerTyID:
 326   case Type::UIntTyID: case Type::IntTyID:
 327     O << ".long";
 328     break;
 329   case Type::ULongTyID: case Type::LongTyID:
 330     assert (0 && "Should have already output double-word constant.");
 331   case Type::FloatTyID: case Type::DoubleTyID:
 332     assert (0 && "Should have already output floating point constant.");
 333   default:
 334     if (CV == Constant::getNullValue(type)) {  // Zero initializer?
 335       O << ".space\t" << TD.getTypeSize(type) << "\n";
 336       return;
 337     }
 338     std::cerr << "Can't handle printing: " << *CV;
 339     abort();
 340     break;
 341   }
 342   O << "\t";
 343   emitConstantValueOnly(CV);
 344   O << "\n";
 345 }
 346
 347 /// printConstantPool - Print to the current output stream assembly
 348 /// representations of the constants in the constant pool MCP. This is
 349 /// used to print out constants which have been "spilled to memory" by
 350 /// the code generator.
 351 ///
 352 void Printer::printConstantPool(MachineConstantPool *MCP) {
 353   const std::vector<Constant*> &CP = MCP->getConstants();
 354   const TargetData &TD = TM.getTargetData();
 355
 356   if (CP.empty()) return;
 357
 358   for (unsigned i = 0, e = CP.size(); i != e; ++i) {
 359     O << "\t.const\n";
 360     O << "\t.align " << (unsigned)TD.getTypeAlignment(CP[i]->getType())
 361       << "\n";
 362     O << ".CPI" << CurrentFnName << "_" << i << ":\t\t\t\t\t;"
 363       << *CP[i] << "\n";
 364     emitGlobalConstant(CP[i]);
 365   }
 366 }
 367
 368 /// runOnMachineFunction - This uses the printMachineInstruction()
 369 /// method to print assembly for each instruction.
 370 ///
 371 bool Printer::runOnMachineFunction(MachineFunction &MF) {
 372   O << "\n\n";
 373   // What's my mangled name?
 374   CurrentFnName = Mang->getValueName(MF.getFunction());
 375
 376   // Print out constants referenced by the function
 377   printConstantPool(MF.getConstantPool());
 378
 379   // Print out labels for the function.
 380   O << "\t.text\n";
 381   O << "\t.globl\t" << CurrentFnName << "\n";
 382   O << "\t.align 2\n";
 383   O << CurrentFnName << ":\n";
 384
 385   // Print out code for the function.
 386   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 387        I != E; ++I) {
 388     // Print a label for the basic block.
 389     O << ".LBB" << CurrentFnName << "_" << I->getNumber() << ":\t; "
 390       << I->getBasicBlock()->getName() << "\n";
 391     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
 392       II != E; ++II) {
 393       // Print the assembly for the instruction.
 394       O << "\t";
 395       printMachineInstruction(II);
 396     }
 397   }
 398   ++LabelNumber;
 399
 400   // We didn't modify anything.
 401   return false;
 402 }
 403
 404 void Printer::printOp(const MachineOperand &MO,
 405                       bool elideOffsetKeyword /* = false */) {
 406   const MRegisterInfo &RI = *TM.getRegisterInfo();
 407   int new_symbol;
 408
 409   switch (MO.getType()) {
 410   case MachineOperand::MO_VirtualRegister:
 411     if (Value *V = MO.getVRegValueOrNull()) {
 412       O << "<" << V->getName() << ">";
 413       return;
 414     }
 415     // FALLTHROUGH
 416   case MachineOperand::MO_MachineRegister:
 417   case MachineOperand::MO_CCRegister:
 418     O << LowercaseString(RI.get(MO.getReg()).Name);
 419     return;
 420
 421   case MachineOperand::MO_SignExtendedImmed:
 422     O << (short)MO.getImmedValue();
 423     return;
 424
 425   case MachineOperand::MO_UnextendedImmed:
 426     O << (unsigned short)MO.getImmedValue();
 427     return;
 428
 429   case MachineOperand::MO_PCRelativeDisp:
 430     std::cerr << "Shouldn't use addPCDisp() when building PPC MachineInstrs";
 431     abort();
 432     return;
 433
 434   case MachineOperand::MO_MachineBasicBlock: {
 435     MachineBasicBlock *MBBOp = MO.getMachineBasicBlock();
 436     O << ".LBB" << Mang->getValueName(MBBOp->getParent()->getFunction())
 437       << "_" << MBBOp->getNumber() << "\t; "
 438       << MBBOp->getBasicBlock()->getName();
 439     return;
 440   }
 441
 442   case MachineOperand::MO_ConstantPoolIndex:
 443     O << ".CPI" << CurrentFnName << "_" << MO.getConstantPoolIndex();
 444     return;
 445
 446   case MachineOperand::MO_ExternalSymbol:
 447     O << MO.getSymbolName();
 448     return;
 449
 450   case MachineOperand::MO_GlobalAddress:
 451     if (!elideOffsetKeyword) {
 452       GlobalValue *GV = MO.getGlobal();
 453       std::string Name = Mang->getValueName(GV);
 454
 455       // Dynamically-resolved functions need a stub for the function
 456       Function *F = dyn_cast<Function>(GV);
 457       if (F && F->isExternal() &&
 458           TM.CalledFunctions.find(F) != TM.CalledFunctions.end()) {
 459         FnStubs.insert(Name);
 460         O << "L" << Name << "$stub";
 461         return;
 462       }
 463
 464       // External global variables need a non-lazily-resolved stub
 465       if (!GV->hasInternalLinkage() &&
 466           TM.AddressTaken.find(GV) != TM.AddressTaken.end()) {
 467         GVStubs.insert(Name);
 468         O << "L" << Name << "$non_lazy_ptr";
 469         return;
 470       }
 471
 472       O << Mang->getValueName(GV);
 473     }
 474     return;
 475
 476   default:
 477     O << "<unknown operand type: " << MO.getType() << ">";
 478     return;
 479   }
 480 }
 481
 482 /// printMachineInstruction -- Print out a single PPC32 LLVM instruction
 483 /// MI in Darwin syntax to the current output stream.
 484 ///
 485 void Printer::printMachineInstruction(const MachineInstr *MI) {
 486   unsigned Opcode = MI->getOpcode();
 487   const TargetInstrInfo &TII = *TM.getInstrInfo();
 488   const TargetInstrDescriptor &Desc = TII.get(Opcode);
 489   unsigned int i;
 490
 491   unsigned int ArgCount = MI->getNumOperands();
 492     //Desc.TSFlags & PPC32II::ArgCountMask;
 493   unsigned int ArgType[] = {
 494     (Desc.TSFlags >> PPC32II::Arg0TypeShift) & PPC32II::ArgTypeMask,
 495     (Desc.TSFlags >> PPC32II::Arg1TypeShift) & PPC32II::ArgTypeMask,
 496     (Desc.TSFlags >> PPC32II::Arg2TypeShift) & PPC32II::ArgTypeMask,
 497     (Desc.TSFlags >> PPC32II::Arg3TypeShift) & PPC32II::ArgTypeMask,
 498     (Desc.TSFlags >> PPC32II::Arg4TypeShift) & PPC32II::ArgTypeMask
 499   };
 500   assert(((Desc.TSFlags & PPC32II::VMX) == 0) &&
 501          "Instruction requires VMX support");
 502   assert(((Desc.TSFlags & PPC32II::PPC64) == 0) &&
 503          "Instruction requires 64 bit support");
 504   ++EmittedInsts;
 505
 506   // CALLpcrel and CALLindirect are handled specially here to print only the
 507   // appropriate number of args that the assembler expects.  This is because
 508   // may have many arguments appended to record the uses of registers that are
 509   // holding arguments to the called function.
 510   if (Opcode == PPC32::COND_BRANCH) {
 511     std::cerr << "Error: untranslated conditional branch psuedo instruction!\n";
 512     abort();
 513   } else if (Opcode == PPC32::IMPLICIT_DEF) {
 514     O << "; IMPLICIT DEF ";
 515     printOp(MI->getOperand(0));
 516     O << "\n";
 517     return;
 518   } else if (Opcode == PPC32::CALLpcrel) {
 519     O << TII.getName(MI->getOpcode()) << " ";
 520     printOp(MI->getOperand(0));
 521     O << "\n";
 522     return;
 523   } else if (Opcode == PPC32::CALLindirect) {
 524     O << TII.getName(MI->getOpcode()) << " ";
 525     printOp(MI->getOperand(0));
 526     O << ", ";
 527     printOp(MI->getOperand(1));
 528     O << "\n";
 529     return;
 530   } else if (Opcode == PPC32::MovePCtoLR) {
 531     // FIXME: should probably be converted to cout.width and cout.fill
 532     O << "bl \"L0000" << LabelNumber << "$pb\"\n";
 533     O << "\"L0000" << LabelNumber << "$pb\":\n";
 534     O << "\tmflr ";
 535     printOp(MI->getOperand(0));
 536     O << "\n";
 537     return;
 538   }
 539
 540   O << TII.getName(MI->getOpcode()) << " ";
 541   if (Opcode == PPC32::LOADLoDirect || Opcode == PPC32::LOADLoIndirect) {
 542     printOp(MI->getOperand(0));
 543     O << ", lo16(";
 544     printOp(MI->getOperand(2));
 545     O << "-\"L0000" << LabelNumber << "$pb\")";
 546     O << "(";
 547     if (MI->getOperand(1).getReg() == PPC32::R0)
 548       O << "0";
 549     else
 550       printOp(MI->getOperand(1));
 551     O << ")\n";
 552   } else if (Opcode == PPC32::LOADHiAddr) {
 553     printOp(MI->getOperand(0));
 554     O << ", ";
 555     if (MI->getOperand(1).getReg() == PPC32::R0)
 556       O << "0";
 557     else
 558       printOp(MI->getOperand(1));
 559     O << ", ha16(" ;
 560     printOp(MI->getOperand(2));
 561      O << "-\"L0000" << LabelNumber << "$pb\")\n";
 562   } else if (ArgCount == 3 && ArgType[1] == PPC32II::Disimm16) {
 563     printOp(MI->getOperand(0));
 564     O << ", ";
 565     printOp(MI->getOperand(1));
 566     O << "(";
 567     if (MI->getOperand(2).hasAllocatedReg() &&
 568         MI->getOperand(2).getReg() == PPC32::R0)
 569       O << "0";
 570     else
 571       printOp(MI->getOperand(2));
 572     O << ")\n";
 573   } else {
 574     for (i = 0; i < ArgCount; ++i) {
 575       // addi and friends
 576       if (i == 1 && ArgCount == 3 && ArgType[2] == PPC32II::Simm16 &&
 577           MI->getOperand(1).hasAllocatedReg() &&
 578           MI->getOperand(1).getReg() == PPC32::R0) {
 579         O << "0";
 580       // for long branch support, bc $+8
 581       } else if (i == 1 && ArgCount == 2 && MI->getOperand(1).isImmediate() &&
 582                  TII.isBranch(MI->getOpcode())) {
 583         O << "$+8";
 584         assert(8 == MI->getOperand(i).getImmedValue()
 585           && "branch off PC not to pc+8?");
 586         //printOp(MI->getOperand(i));
 587       } else {
 588         printOp(MI->getOperand(i));
 589       }
 590       if (ArgCount - 1 == i)
 591         O << "\n";
 592       else
 593         O << ", ";
 594     }
 595   }
 596 }
 597
 598 bool Printer::doInitialization(Module &M) {
 599   Mang = new Mangler(M, true);
 600   return false; // success
 601 }
 602
 603 // SwitchSection - Switch to the specified section of the executable if we are
 604 // not already in it!
 605 //
 606 static void SwitchSection(std::ostream &OS, std::string &CurSection,
 607                           const char *NewSection) {
 608   if (CurSection != NewSection) {
 609     CurSection = NewSection;
 610     if (!CurSection.empty())
 611       OS << "\t" << NewSection << "\n";
 612   }
 613 }
 614
 615 bool Printer::doFinalization(Module &M) {
 616   const TargetData &TD = TM.getTargetData();
 617   std::string CurSection;
 618
 619   // Print out module-level global variables here.
 620   for (Module::const_giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
 621     if (I->hasInitializer()) {   // External global require no code
 622       O << "\n\n";
 623       std::string name = Mang->getValueName(I);
 624       Constant *C = I->getInitializer();
 625       unsigned Size = TD.getTypeSize(C->getType());
 626       unsigned Align = TD.getTypeAlignment(C->getType());
 627
 628       if (C->isNullValue() && /* FIXME: Verify correct */
 629           (I->hasInternalLinkage() || I->hasWeakLinkage())) {
 630         SwitchSection(O, CurSection, ".data");
 631         if (I->hasInternalLinkage())
 632           O << ".lcomm " << name << "," << TD.getTypeSize(C->getType())
 633             << "," << (unsigned)TD.getTypeAlignment(C->getType());
 634         else
 635           O << ".comm " << name << "," << TD.getTypeSize(C->getType());
 636         O << "\t\t; ";
 637         WriteAsOperand(O, I, true, true, &M);
 638         O << "\n";
 639       } else {
 640         switch (I->getLinkage()) {
 641         case GlobalValue::LinkOnceLinkage:
 642           O << ".section __TEXT,__textcoal_nt,coalesced,no_toc\n"
 643             << ".weak_definition " << name << '\n'
 644             << ".private_extern " << name << '\n'
 645             << ".section __DATA,__datacoal_nt,coalesced,no_toc\n";
 646           LinkOnceStubs.insert(name);
 647           break;
 648         case GlobalValue::WeakLinkage:   // FIXME: Verify correct for weak.
 649           // Nonnull linkonce -> weak
 650           O << "\t.weak " << name << "\n";
 651           SwitchSection(O, CurSection, "");
 652           O << "\t.section\t.llvm.linkonce.d." << name << ",\"aw\",@progbits\n";
 653           break;
 654         case GlobalValue::AppendingLinkage:
 655           // FIXME: appending linkage variables should go into a section of
 656           // their name or something.  For now, just emit them as external.
 657         case GlobalValue::ExternalLinkage:
 658           // If external or appending, declare as a global symbol
 659           O << "\t.globl " << name << "\n";
 660           // FALL THROUGH
 661         case GlobalValue::InternalLinkage:
 662           SwitchSection(O, CurSection, ".data");
 663           break;
 664         }
 665
 666         O << "\t.align " << Align << "\n";
 667         O << name << ":\t\t\t\t; ";
 668         WriteAsOperand(O, I, true, true, &M);
 669         O << " = ";
 670         WriteAsOperand(O, C, false, false, &M);
 671         O << "\n";
 672         emitGlobalConstant(C);
 673       }
 674     }
 675
 676   // Output stubs for link-once variables
 677   if (LinkOnceStubs.begin() != LinkOnceStubs.end())
 678     O << ".data\n.align 2\n";
 679   for (std::set<std::string>::iterator i = LinkOnceStubs.begin(),
 680          e = LinkOnceStubs.end(); i != e; ++i) {
 681     O << *i << "$non_lazy_ptr:\n"
 682       << "\t.long\t" << *i << '\n';
 683   }
 684
 685   // Output stubs for dynamically-linked functions
 686   for (std::set<std::string>::iterator i = FnStubs.begin(), e = FnStubs.end();
 687        i != e; ++i)
 688   {
 689     O << ".data\n";
 690     O << ".section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32\n";
 691     O << "\t.align 2\n";
 692     O << "L" << *i << "$stub:\n";
 693     O << "\t.indirect_symbol " << *i << "\n";
 694     O << "\tmflr r0\n";
 695     O << "\tbcl 20,31,L0$" << *i << "\n";
 696     O << "L0$" << *i << ":\n";
 697     O << "\tmflr r11\n";
 698     O << "\taddis r11,r11,ha16(L" << *i << "$lazy_ptr-L0$" << *i << ")\n";
 699     O << "\tmtlr r0\n";
 700     O << "\tlwzu r12,lo16(L" << *i << "$lazy_ptr-L0$" << *i << ")(r11)\n";
 701     O << "\tmtctr r12\n";
 702     O << "\tbctr\n";
 703     O << ".data\n";
 704     O << ".lazy_symbol_pointer\n";
 705     O << "L" << *i << "$lazy_ptr:\n";
 706     O << "\t.indirect_symbol " << *i << "\n";
 707     O << "\t.long dyld_stub_binding_helper\n";
 708   }
 709
 710   O << "\n";
 711
 712   // Output stubs for external global variables
 713   if (GVStubs.begin() != GVStubs.end())
 714     O << ".data\n.non_lazy_symbol_pointer\n";
 715   for (std::set<std::string>::iterator i = GVStubs.begin(), e = GVStubs.end();
 716        i != e; ++i) {
 717     O << "L" << *i << "$non_lazy_ptr:\n";
 718     O << "\t.indirect_symbol " << *i << "\n";
 719     O << "\t.long\t0\n";
 720   }
 721
 722   delete Mang;
 723   return false; // success
 724 }
 725
 726 } // End llvm namespace