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
  69     /// Global values.
  70     ///
  71     unsigned int labelNumber;
  72
  73     virtual const char *getPassName() const {
  74       return "PowerPC Assembly Printer";
  75     }
  76
  77     void printMachineInstruction(const MachineInstr *MI);
  78     void printOp(const MachineOperand &MO, bool elideOffsetKeyword = false);
  79     void printConstantPool(MachineConstantPool *MCP);
  80     bool runOnMachineFunction(MachineFunction &F);
  81     bool doInitialization(Module &M);
  82     bool doFinalization(Module &M);
  83     void emitGlobalConstant(const Constant* CV);
  84     void emitConstantValueOnly(const Constant *CV);
  85   };
  86 } // end of anonymous namespace
  87
  88 /// createPPCCodePrinterPass - Returns a pass that prints the PPC
  89 /// assembly code for a MachineFunction to the given output stream,
  90 /// using the given target machine description.  This should work
  91 /// regardless of whether the function is in SSA form.
  92 ///
  93 FunctionPass *createPPCCodePrinterPass(std::ostream &o,TargetMachine &tm) {
  94   return new Printer(o, tm);
  95 }
  96
  97 /// isStringCompatible - Can we treat the specified array as a string?
  98 /// Only if it is an array of ubytes or non-negative sbytes.
  99 ///
 100 static bool isStringCompatible(const ConstantArray *CVA) {
 101   const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
 102   if (ETy == Type::UByteTy) return true;
 103   if (ETy != Type::SByteTy) return false;
 104
 105   for (unsigned i = 0; i < CVA->getNumOperands(); ++i)
 106     if (cast<ConstantSInt>(CVA->getOperand(i))->getValue() < 0)
 107       return false;
 108
 109   return true;
 110 }
 111
 112 /// toOctal - Convert the low order bits of X into an octal digit.
 113 ///
 114 static inline char toOctal(int X) {
 115   return (X&7)+'0';
 116 }
 117
 118 /// getAsCString - Return the specified array as a C compatible
 119 /// string, only if the predicate isStringCompatible is true.
 120 ///
 121 static void printAsCString(std::ostream &O, const ConstantArray *CVA) {
 122   assert(isStringCompatible(CVA) && "Array is not string compatible!");
 123
 124   O << "\"";
 125   for (unsigned i = 0; i < CVA->getNumOperands(); ++i) {
 126     unsigned char C = cast<ConstantInt>(CVA->getOperand(i))->getRawValue();
 127
 128     if (C == '"') {
 129       O << "\\\"";
 130     } else if (C == '\\') {
 131       O << "\\\\";
 132     } else if (isprint(C)) {
 133       O << C;
 134     } else {
 135       switch (C) {
 136       case '\b': O << "\\b"; break;
 137       case '\f': O << "\\f"; break;
 138       case '\n': O << "\\n"; break;
 139       case '\r': O << "\\r"; break;
 140       case '\t': O << "\\t"; break;
 141       default:
 142         O << '\\';
 143         O << toOctal(C >> 6);
 144         O << toOctal(C >> 3);
 145         O << toOctal(C >> 0);
 146         break;
 147       }
 148     }
 149   }
 150   O << "\"";
 151 }
 152
 153 // Print out the specified constant, without a storage class.  Only the
 154 // constants valid in constant expressions can occur here.
 155 void Printer::emitConstantValueOnly(const Constant *CV) {
 156   if (CV->isNullValue())
 157     O << "0";
 158   else if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
 159     assert(CB == ConstantBool::True);
 160     O << "1";
 161   } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV))
 162     O << CI->getValue();
 163   else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV))
 164     O << CI->getValue();
 165   else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV))
 166     // This is a constant address for a global variable or function.  Use the
 167     // name of the variable or function as the address value.
 168     O << Mang->getValueName(GV);
 169   else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
 170     const TargetData &TD = TM.getTargetData();
 171     switch (CE->getOpcode()) {
 172     case Instruction::GetElementPtr: {
 173       // generate a symbolic expression for the byte address
 174       const Constant *ptrVal = CE->getOperand(0);
 175       std::vector<Value*> idxVec(CE->op_begin()+1, CE->op_end());
 176       if (unsigned Offset = TD.getIndexedOffset(ptrVal->getType(), idxVec)) {
 177         O << "(";
 178         emitConstantValueOnly(ptrVal);
 179         O << ") + " << Offset;
 180       } else {
 181         emitConstantValueOnly(ptrVal);
 182       }
 183       break;
 184     }
 185     case Instruction::Cast: {
 186       // Support only non-converting or widening casts for now, that is, ones
 187       // that do not involve a change in value.  This assertion is really gross,
 188       // and may not even be a complete check.
 189       Constant *Op = CE->getOperand(0);
 190       const Type *OpTy = Op->getType(), *Ty = CE->getType();
 191
 192       // Remember, kids, pointers on x86 can be losslessly converted back and
 193       // forth into 32-bit or wider integers, regardless of signedness. :-P
 194       assert(((isa<PointerType>(OpTy)
 195                && (Ty == Type::LongTy || Ty == Type::ULongTy
 196                    || Ty == Type::IntTy || Ty == Type::UIntTy))
 197               || (isa<PointerType>(Ty)
 198                   && (OpTy == Type::LongTy || OpTy == Type::ULongTy
 199                       || OpTy == Type::IntTy || OpTy == Type::UIntTy))
 200               || (((TD.getTypeSize(Ty) >= TD.getTypeSize(OpTy))
 201                    && OpTy->isLosslesslyConvertibleTo(Ty))))
 202              && "FIXME: Don't yet support this kind of constant cast expr");
 203       O << "(";
 204       emitConstantValueOnly(Op);
 205       O << ")";
 206       break;
 207     }
 208     case Instruction::Add:
 209       O << "(";
 210       emitConstantValueOnly(CE->getOperand(0));
 211       O << ") + (";
 212       emitConstantValueOnly(CE->getOperand(1));
 213       O << ")";
 214       break;
 215     default:
 216       assert(0 && "Unsupported operator!");
 217     }
 218   } else {
 219     assert(0 && "Unknown constant value!");
 220   }
 221 }
 222
 223 // Print a constant value or values, with the appropriate storage class as a
 224 // prefix.
 225 void Printer::emitGlobalConstant(const Constant *CV) {
 226   const TargetData &TD = TM.getTargetData();
 227
 228   if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) {
 229     if (isStringCompatible(CVA)) {
 230       O << "\t.ascii ";
 231       printAsCString(O, CVA);
 232       O << "\n";
 233     } else { // Not a string.  Print the values in successive locations
 234       const std::vector<Use> &constValues = CVA->getValues();
 235       for (unsigned i=0; i < constValues.size(); i++)
 236         emitGlobalConstant(cast<Constant>(constValues[i].get()));
 237     }
 238     return;
 239   } else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) {
 240     // Print the fields in successive locations. Pad to align if needed!
 241     const StructLayout *cvsLayout = TD.getStructLayout(CVS->getType());
 242     const std::vector<Use>& constValues = CVS->getValues();
 243     unsigned sizeSoFar = 0;
 244     for (unsigned i=0, N = constValues.size(); i < N; i++) {
 245       const Constant* field = cast<Constant>(constValues[i].get());
 246
 247       // Check if padding is needed and insert one or more 0s.
 248       unsigned fieldSize = TD.getTypeSize(field->getType());
 249       unsigned padSize = ((i == N-1? cvsLayout->StructSize
 250                            : cvsLayout->MemberOffsets[i+1])
 251                           - cvsLayout->MemberOffsets[i]) - fieldSize;
 252       sizeSoFar += fieldSize + padSize;
 253
 254       // Now print the actual field value
 255       emitGlobalConstant(field);
 256
 257       // Insert the field padding unless it's zero bytes...
 258       if (padSize)
 259         O << "\t.space\t " << padSize << "\n";
 260     }
 261     assert(sizeSoFar == cvsLayout->StructSize &&
 262            "Layout of constant struct may be incorrect!");
 263     return;
 264   } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
 265     // FP Constants are printed as integer constants to avoid losing
 266     // precision...
 267     double Val = CFP->getValue();
 268     switch (CFP->getType()->getTypeID()) {
 269     default: assert(0 && "Unknown floating point type!");
 270     case Type::FloatTyID: {
 271       union FU {                            // Abide by C TBAA rules
 272         float FVal;
 273         unsigned UVal;
 274       } U;
 275       U.FVal = Val;
 276       O << ".long\t" << U.UVal << "\t; float " << Val << "\n";
 277       return;
 278     }
 279     case Type::DoubleTyID: {
 280       union DU {                            // Abide by C TBAA rules
 281         double FVal;
 282         uint64_t UVal;
 283         struct {
 284           uint32_t MSWord;
 285           uint32_t LSWord;
 286         } T;
 287       } U;
 288       U.FVal = Val;
 289
 290       O << ".long\t" << U.T.MSWord << "\t; double most significant word "
 291         << Val << "\n";
 292       O << ".long\t" << U.T.LSWord << "\t; double least significant word "
 293         << Val << "\n";
 294       return;
 295     }
 296     }
 297   } else if (CV->getType()->getPrimitiveSize() == 64) {
 298     if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
 299       union DU {                            // Abide by C TBAA rules
 300         int64_t UVal;
 301         struct {
 302           uint32_t MSWord;
 303           uint32_t LSWord;
 304         } T;
 305       } U;
 306       U.UVal = CI->getRawValue();
 307
 308       O << ".long\t" << U.T.MSWord << "\t; Double-word most significant word "
 309         << U.UVal << "\n";
 310       O << ".long\t" << U.T.LSWord << "\t; Double-word least significant word "
 311         << U.UVal << "\n";
 312       return;
 313     }
 314   }
 315
 316   const Type *type = CV->getType();
 317   O << "\t";
 318   switch (type->getTypeID()) {
 319   case Type::UByteTyID: case Type::SByteTyID:
 320     O << ".byte";
 321     break;
 322   case Type::UShortTyID: case Type::ShortTyID:
 323     O << ".short";
 324     break;
 325   case Type::BoolTyID:
 326   case Type::PointerTyID:
 327   case Type::UIntTyID: case Type::IntTyID:
 328     O << ".long";
 329     break;
 330   case Type::ULongTyID: case Type::LongTyID:
 331     assert (0 && "Should have already output double-word constant.");
 332   case Type::FloatTyID: case Type::DoubleTyID:
 333     assert (0 && "Should have already output floating point constant.");
 334   default:
 335     if (CV == Constant::getNullValue(type)) {  // Zero initializer?
 336       O << ".space\t" << TD.getTypeSize(type) << "\n";
 337       return;
 338     }
 339     std::cerr << "Can't handle printing: " << *CV;
 340     abort();
 341     break;
 342   }
 343   O << "\t";
 344   emitConstantValueOnly(CV);
 345   O << "\n";
 346 }
 347
 348 /// printConstantPool - Print to the current output stream assembly
 349 /// representations of the constants in the constant pool MCP. This is
 350 /// used to print out constants which have been "spilled to memory" by
 351 /// the code generator.
 352 ///
 353 void Printer::printConstantPool(MachineConstantPool *MCP) {
 354   const std::vector<Constant*> &CP = MCP->getConstants();
 355   const TargetData &TD = TM.getTargetData();
 356
 357   if (CP.empty()) return;
 358
 359   for (unsigned i = 0, e = CP.size(); i != e; ++i) {
 360     O << "\t.const\n";
 361     O << "\t.align " << (unsigned)TD.getTypeAlignment(CP[i]->getType())
 362       << "\n";
 363     O << ".CPI" << CurrentFnName << "_" << i << ":\t\t\t\t\t;"
 364       << *CP[i] << "\n";
 365     emitGlobalConstant(CP[i]);
 366   }
 367 }
 368
 369 /// runOnMachineFunction - This uses the printMachineInstruction()
 370 /// method to print assembly for each instruction.
 371 ///
 372 bool Printer::runOnMachineFunction(MachineFunction &MF) {
 373   O << "\n\n";
 374   // What's my mangled name?
 375   CurrentFnName = Mang->getValueName(MF.getFunction());
 376
 377   // Print out constants referenced by the function
 378   printConstantPool(MF.getConstantPool());
 379
 380   // Print out labels for the function.
 381   O << "\t.text\n";
 382   O << "\t.globl\t" << CurrentFnName << "\n";
 383   O << "\t.align 2\n";
 384   O << CurrentFnName << ":\n";
 385
 386   // Print out code for the function.
 387   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 388        I != E; ++I) {
 389     // Print a label for the basic block.
 390     O << ".LBB" << CurrentFnName << "_" << I->getNumber() << ":\t; "
 391       << I->getBasicBlock()->getName() << "\n";
 392     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
 393       II != E; ++II) {
 394       // Print the assembly for the instruction.
 395       O << "\t";
 396       printMachineInstruction(II);
 397     }
 398   }
 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::IMPLICIT_DEF) {
 511     O << "; IMPLICIT DEF ";
 512     printOp(MI->getOperand(0));
 513     O << "\n";
 514     return;
 515   } else if (Opcode == PPC32::CALLpcrel) {
 516     O << TII.getName(MI->getOpcode()) << " ";
 517     printOp(MI->getOperand(0));
 518     O << "\n";
 519     return;
 520   } else if (Opcode == PPC32::CALLindirect) {
 521     O << TII.getName(MI->getOpcode()) << " ";
 522     printOp(MI->getOperand(0));
 523     O << ", ";
 524     printOp(MI->getOperand(1));
 525     O << "\n";
 526     return;
 527   } else if (Opcode == PPC32::MovePCtoLR) {
 528     // FIXME: should probably be converted to cout.width and cout.fill
 529     O << "bl \"L0000" << labelNumber << "$pb\"\n";
 530     O << "\"L0000" << labelNumber << "$pb\":\n";
 531     O << "\tmflr ";
 532     printOp(MI->getOperand(0));
 533     O << "\n";
 534     return;
 535   }
 536
 537   O << TII.getName(MI->getOpcode()) << " ";
 538   if (Opcode == PPC32::LOADLoDirect || Opcode == PPC32::LOADLoIndirect) {
 539     printOp(MI->getOperand(0));
 540     O << ", lo16(";
 541     printOp(MI->getOperand(2));
 542     O << "-\"L0000" << labelNumber << "$pb\")";
 543     labelNumber++;
 544     O << "(";
 545     if (MI->getOperand(1).getReg() == PPC32::R0)
 546       O << "0";
 547     else
 548       printOp(MI->getOperand(1));
 549     O << ")\n";
 550   } else if (Opcode == PPC32::LOADHiAddr) {
 551     printOp(MI->getOperand(0));
 552     O << ", ";
 553     if (MI->getOperand(1).getReg() == PPC32::R0)
 554       O << "0";
 555     else
 556       printOp(MI->getOperand(1));
 557     O << ", ha16(" ;
 558     printOp(MI->getOperand(2));
 559      O << "-\"L0000" << labelNumber << "$pb\")\n";
 560   } else if (ArgCount == 3 && ArgType[1] == PPC32II::Disimm16) {
 561     printOp(MI->getOperand(0));
 562     O << ", ";
 563     printOp(MI->getOperand(1));
 564     O << "(";
 565     if (MI->getOperand(2).hasAllocatedReg() &&
 566         MI->getOperand(2).getReg() == PPC32::R0)
 567       O << "0";
 568     else
 569       printOp(MI->getOperand(2));
 570     O << ")\n";
 571   } else {
 572     for (i = 0; i < ArgCount; ++i) {
 573       if (i == 1 && ArgCount == 3 && ArgType[2] == PPC32II::Simm16 &&
 574           MI->getOperand(1).hasAllocatedReg() &&
 575           MI->getOperand(1).getReg() == PPC32::R0) {
 576         O << "0";
 577       } else {
 578         printOp(MI->getOperand(i));
 579       }
 580       if (ArgCount - 1 == i)
 581         O << "\n";
 582       else
 583         O << ", ";
 584     }
 585   }
 586 }
 587
 588 bool Printer::doInitialization(Module &M) {
 589   Mang = new Mangler(M, true);
 590   return false; // success
 591 }
 592
 593 // SwitchSection - Switch to the specified section of the executable if we are
 594 // not already in it!
 595 //
 596 static void SwitchSection(std::ostream &OS, std::string &CurSection,
 597                           const char *NewSection) {
 598   if (CurSection != NewSection) {
 599     CurSection = NewSection;
 600     if (!CurSection.empty())
 601       OS << "\t" << NewSection << "\n";
 602   }
 603 }
 604
 605 bool Printer::doFinalization(Module &M) {
 606   const TargetData &TD = TM.getTargetData();
 607   std::string CurSection;
 608
 609   // Print out module-level global variables here.
 610   for (Module::const_giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
 611     if (I->hasInitializer()) {   // External global require no code
 612       O << "\n\n";
 613       std::string name = Mang->getValueName(I);
 614       Constant *C = I->getInitializer();
 615       unsigned Size = TD.getTypeSize(C->getType());
 616       unsigned Align = TD.getTypeAlignment(C->getType());
 617
 618       if (C->isNullValue() && /* FIXME: Verify correct */
 619           (I->hasInternalLinkage() || I->hasWeakLinkage())) {
 620         SwitchSection(O, CurSection, ".data");
 621         if (I->hasInternalLinkage())
 622           O << ".lcomm " << name << "," << TD.getTypeSize(C->getType())
 623             << "," << (unsigned)TD.getTypeAlignment(C->getType());
 624         else
 625           O << ".comm " << name << "," << TD.getTypeSize(C->getType());
 626         O << "\t\t; ";
 627         WriteAsOperand(O, I, true, true, &M);
 628         O << "\n";
 629       } else {
 630         switch (I->getLinkage()) {
 631         case GlobalValue::LinkOnceLinkage:
 632           O << ".section __TEXT,__textcoal_nt,coalesced,no_toc\n"
 633             << ".weak_definition " << name << '\n'
 634             << ".private_extern " << name << '\n'
 635             << ".section __DATA,__datacoal_nt,coalesced,no_toc\n";
 636           LinkOnceStubs.insert(name);
 637           break;
 638         case GlobalValue::WeakLinkage:   // FIXME: Verify correct for weak.
 639           // Nonnull linkonce -> weak
 640           O << "\t.weak " << name << "\n";
 641           SwitchSection(O, CurSection, "");
 642           O << "\t.section\t.llvm.linkonce.d." << name << ",\"aw\",@progbits\n";
 643           break;
 644         case GlobalValue::AppendingLinkage:
 645           // FIXME: appending linkage variables should go into a section of
 646           // their name or something.  For now, just emit them as external.
 647         case GlobalValue::ExternalLinkage:
 648           // If external or appending, declare as a global symbol
 649           O << "\t.globl " << name << "\n";
 650           // FALL THROUGH
 651         case GlobalValue::InternalLinkage:
 652           SwitchSection(O, CurSection, ".data");
 653           break;
 654         }
 655
 656         O << "\t.align " << Align << "\n";
 657         O << name << ":\t\t\t\t; ";
 658         WriteAsOperand(O, I, true, true, &M);
 659         O << " = ";
 660         WriteAsOperand(O, C, false, false, &M);
 661         O << "\n";
 662         emitGlobalConstant(C);
 663       }
 664     }
 665
 666   // Output stubs for link-once variables
 667   if (LinkOnceStubs.begin() != LinkOnceStubs.end())
 668     O << ".data\n.align 2\n";
 669   for (std::set<std::string>::iterator i = LinkOnceStubs.begin(),
 670          e = LinkOnceStubs.end(); i != e; ++i) {
 671     O << *i << "$non_lazy_ptr:\n"
 672       << "\t.long\t" << *i << '\n';
 673   }
 674
 675   // Output stubs for dynamically-linked functions
 676   for (std::set<std::string>::iterator i = FnStubs.begin(), e = FnStubs.end();
 677        i != e; ++i)
 678   {
 679     O << ".data\n";
 680     O << ".section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32\n";
 681     O << "\t.align 2\n";
 682     O << "L" << *i << "$stub:\n";
 683     O << "\t.indirect_symbol " << *i << "\n";
 684     O << "\tmflr r0\n";
 685     O << "\tbcl 20,31,L0$" << *i << "\n";
 686     O << "L0$" << *i << ":\n";
 687     O << "\tmflr r11\n";
 688     O << "\taddis r11,r11,ha16(L" << *i << "$lazy_ptr-L0$" << *i << ")\n";
 689     O << "\tmtlr r0\n";
 690     O << "\tlwzu r12,lo16(L" << *i << "$lazy_ptr-L0$" << *i << ")(r11)\n";
 691     O << "\tmtctr r12\n";
 692     O << "\tbctr\n";
 693     O << ".data\n";
 694     O << ".lazy_symbol_pointer\n";
 695     O << "L" << *i << "$lazy_ptr:\n";
 696     O << "\t.indirect_symbol " << *i << "\n";
 697     O << "\t.long dyld_stub_binding_helper\n";
 698   }
 699
 700   O << "\n";
 701
 702   // Output stubs for external global variables
 703   if (GVStubs.begin() != GVStubs.end())
 704     O << ".data\n.non_lazy_symbol_pointer\n";
 705   for (std::set<std::string>::iterator i = GVStubs.begin(), e = GVStubs.end();
 706        i != e; ++i) {
 707     O << "L" << *i << "$non_lazy_ptr:\n";
 708     O << "\t.indirect_symbol " << *i << "\n";
 709     O << "\t.long\t0\n";
 710   }
 711
 712   delete Mang;
 713   return false; // success
 714 }
 715
 716 } // End llvm namespace