PPCAsmPrinter.cpp revision 97a296f743c3cb78ae106a8e4800a5daa0ca6fc9 
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 "llvm/Constants.h"
23#include "llvm/DerivedTypes.h"
24#include "llvm/Module.h"
25#include "llvm/Assembly/Writer.h"
26#include "llvm/CodeGen/MachineConstantPool.h"
27#include "llvm/CodeGen/MachineFunctionPass.h"
28#include "llvm/CodeGen/MachineInstr.h"
29#include "llvm/Target/TargetMachine.h"
30#include "llvm/Support/Mangler.h"
31#include "Support/CommandLine.h"
32#include "Support/Debug.h"
33#include "Support/Statistic.h"
34#include "Support/StringExtras.h"
35#include <set>
36
37namespace llvm {
38
39namespace {
40  Statistic<> EmittedInsts("asm-printer", "Number of machine instrs printed");
41
42  struct Printer : public MachineFunctionPass {
43    /// Output stream on which we're printing assembly code.
44    ///
45    std::ostream &O;
46
47    /// Target machine description which we query for reg. names, data
48    /// layout, etc.
49    ///
50    TargetMachine &TM;
51
52    /// Name-mangler for global names.
53    ///
54    Mangler *Mang;
55    std::set<std::string> FnStubs, GVStubs, LinkOnceStubs;
56    std::set<std::string> Strings;
57
58    Printer(std::ostream &o, TargetMachine &tm) : O(o), TM(tm), labelNumber(0)
59      { }
60
61    /// Cache of mangled name for current function. This is
62    /// recalculated at the beginning of each call to
63    /// runOnMachineFunction().
64    ///
65    std::string CurrentFnName;
66
67    /// Unique incrementer for label values for referencing
68    /// Global values.
69    ///
70    unsigned int 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///
92FunctionPass *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///
99static 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///
113static 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///
120static 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.
154void 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.
224void 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///
352void 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///
371bool 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
399  // We didn't modify anything.
400  return false;
401}
402
403void Printer::printOp(const MachineOperand &MO,
404                      bool elideOffsetKeyword /* = false */) {
405  const MRegisterInfo &RI = *TM.getRegisterInfo();
406  int new_symbol;
407
408  switch (MO.getType()) {
409  case MachineOperand::MO_VirtualRegister:
410    if (Value *V = MO.getVRegValueOrNull()) {
411      O << "<" << V->getName() << ">";
412      return;
413    }
414    // FALLTHROUGH
415  case MachineOperand::MO_MachineRegister:
416  case MachineOperand::MO_CCRegister:
417    O << LowercaseString(RI.get(MO.getReg()).Name);
418    return;
419
420  case MachineOperand::MO_SignExtendedImmed:
421    O << (short)MO.getImmedValue();
422    return;
423
424  case MachineOperand::MO_UnextendedImmed:
425    O << (unsigned short)MO.getImmedValue();
426    return;
427
428  case MachineOperand::MO_PCRelativeDisp:
429    std::cerr << "Shouldn't use addPCDisp() when building PPC MachineInstrs";
430    abort();
431    return;
432
433  case MachineOperand::MO_MachineBasicBlock: {
434    MachineBasicBlock *MBBOp = MO.getMachineBasicBlock();
435    O << ".LBB" << Mang->getValueName(MBBOp->getParent()->getFunction())
436      << "_" << MBBOp->getNumber() << "\t; "
437      << MBBOp->getBasicBlock()->getName();
438    return;
439  }
440
441  case MachineOperand::MO_ConstantPoolIndex:
442    O << ".CPI" << CurrentFnName << "_" << MO.getConstantPoolIndex();
443    return;
444
445  case MachineOperand::MO_ExternalSymbol:
446    O << MO.getSymbolName();
447    return;
448
449  case MachineOperand::MO_GlobalAddress:
450    if (!elideOffsetKeyword) {
451      GlobalValue *GV = MO.getGlobal();
452      std::string Name = Mang->getValueName(GV);
453      // Dynamically-resolved functions need a stub for the function
454      Function *F = dyn_cast<Function>(GV);
455      if (F && F->isExternal()) {
456        FnStubs.insert(Name);
457        O << "L" << Name << "$stub";
458      } else {
459        GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
460        // External global variables need a non-lazily-resolved stub
461        if (GVar && GVar->isExternal()) {
462          GVStubs.insert(Name);
463          O << "L" << Name << "$non_lazy_ptr";
464        } else
465          O << Mang->getValueName(GV);
466      }
467    }
468    return;
469
470  default:
471    O << "<unknown operand type: " << MO.getType() << ">";
472    return;
473  }
474}
475
476/// printMachineInstruction -- Print out a single PPC32 LLVM instruction
477/// MI in Darwin syntax to the current output stream.
478///
479void Printer::printMachineInstruction(const MachineInstr *MI) {
480  unsigned Opcode = MI->getOpcode();
481  const TargetInstrInfo &TII = *TM.getInstrInfo();
482  const TargetInstrDescriptor &Desc = TII.get(Opcode);
483  unsigned int i;
484
485  unsigned int ArgCount = MI->getNumOperands();
486    //Desc.TSFlags & PPC32II::ArgCountMask;
487  unsigned int ArgType[] = {
488    (Desc.TSFlags >> PPC32II::Arg0TypeShift) & PPC32II::ArgTypeMask,
489    (Desc.TSFlags >> PPC32II::Arg1TypeShift) & PPC32II::ArgTypeMask,
490    (Desc.TSFlags >> PPC32II::Arg2TypeShift) & PPC32II::ArgTypeMask,
491    (Desc.TSFlags >> PPC32II::Arg3TypeShift) & PPC32II::ArgTypeMask,
492    (Desc.TSFlags >> PPC32II::Arg4TypeShift) & PPC32II::ArgTypeMask
493  };
494  assert(((Desc.TSFlags & PPC32II::VMX) == 0) &&
495         "Instruction requires VMX support");
496  assert(((Desc.TSFlags & PPC32II::PPC64) == 0) &&
497         "Instruction requires 64 bit support");
498  ++EmittedInsts;
499
500  // CALLpcrel and CALLindirect are handled specially here to print only the
501  // appropriate number of args that the assembler expects.  This is because
502  // may have many arguments appended to record the uses of registers that are
503  // holding arguments to the called function.
504  if (Opcode == PPC32::IMPLICIT_DEF) {
505    O << "; IMPLICIT DEF ";
506    printOp(MI->getOperand(0));
507    O << "\n";
508    return;
509  } else if (Opcode == PPC32::CALLpcrel) {
510    O << TII.getName(MI->getOpcode()) << " ";
511    printOp(MI->getOperand(0));
512    O << "\n";
513    return;
514  } else if (Opcode == PPC32::CALLindirect) {
515    O << TII.getName(MI->getOpcode()) << " ";
516    printOp(MI->getOperand(0));
517    O << ", ";
518    printOp(MI->getOperand(1));
519    O << "\n";
520    return;
521  } else if (Opcode == PPC32::MovePCtoLR) {
522    // FIXME: should probably be converted to cout.width and cout.fill
523    O << "bl \"L0000" << labelNumber << "$pb\"\n";
524    O << "\"L0000" << labelNumber << "$pb\":\n";
525    O << "\tmflr ";
526    printOp(MI->getOperand(0));
527    O << "\n";
528    return;
529  }
530
531  O << TII.getName(MI->getOpcode()) << " ";
532  if (Opcode == PPC32::LOADLoDirect || Opcode == PPC32::LOADLoIndirect) {
533    printOp(MI->getOperand(0));
534    O << ", lo16(";
535    printOp(MI->getOperand(2));
536    O << "-\"L0000" << labelNumber << "$pb\")";
537    labelNumber++;
538    O << "(";
539    if (MI->getOperand(1).getReg() == PPC32::R0)
540      O << "0";
541    else
542      printOp(MI->getOperand(1));
543    O << ")\n";
544  } else if (Opcode == PPC32::LOADHiAddr) {
545    printOp(MI->getOperand(0));
546    O << ", ";
547    if (MI->getOperand(1).getReg() == PPC32::R0)
548      O << "0";
549    else
550      printOp(MI->getOperand(1));
551    O << ", ha16(" ;
552    printOp(MI->getOperand(2));
553     O << "-\"L0000" << labelNumber << "$pb\")\n";
554  } else if (ArgCount == 3 && ArgType[1] == PPC32II::Disimm16) {
555    printOp(MI->getOperand(0));
556    O << ", ";
557    printOp(MI->getOperand(1));
558    O << "(";
559    if (MI->getOperand(2).hasAllocatedReg() &&
560        MI->getOperand(2).getReg() == PPC32::R0)
561      O << "0";
562    else
563      printOp(MI->getOperand(2));
564    O << ")\n";
565  } else {
566    for (i = 0; i < ArgCount; ++i) {
567      if (i == 1 && ArgCount == 3 && ArgType[2] == PPC32II::Simm16 &&
568          MI->getOperand(1).hasAllocatedReg() &&
569          MI->getOperand(1).getReg() == PPC32::R0) {
570        O << "0";
571      } else {
572        printOp(MI->getOperand(i));
573      }
574      if (ArgCount - 1 == i)
575        O << "\n";
576      else
577        O << ", ";
578    }
579  }
580}
581
582bool Printer::doInitialization(Module &M) {
583  Mang = new Mangler(M, true);
584  return false; // success
585}
586
587// SwitchSection - Switch to the specified section of the executable if we are
588// not already in it!
589//
590static void SwitchSection(std::ostream &OS, std::string &CurSection,
591                          const char *NewSection) {
592  if (CurSection != NewSection) {
593    CurSection = NewSection;
594    if (!CurSection.empty())
595      OS << "\t" << NewSection << "\n";
596  }
597}
598
599bool Printer::doFinalization(Module &M) {
600  const TargetData &TD = TM.getTargetData();
601  std::string CurSection;
602
603  // Print out module-level global variables here.
604  for (Module::const_giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
605    if (I->hasInitializer()) {   // External global require no code
606      O << "\n\n";
607      std::string name = Mang->getValueName(I);
608      Constant *C = I->getInitializer();
609      unsigned Size = TD.getTypeSize(C->getType());
610      unsigned Align = TD.getTypeAlignment(C->getType());
611
612      if (C->isNullValue() && /* FIXME: Verify correct */
613          (I->hasInternalLinkage() || I->hasWeakLinkage())) {
614        SwitchSection(O, CurSection, ".data");
615        if (I->hasInternalLinkage())
616          O << "\t.lcomm " << name << "," << TD.getTypeSize(C->getType())
617            << "," << (unsigned)TD.getTypeAlignment(C->getType());
618        else
619          O << "\t.comm " << name << "," << TD.getTypeSize(C->getType());
620        O << "\t\t; ";
621        WriteAsOperand(O, I, true, true, &M);
622        O << "\n";
623      } else {
624        switch (I->getLinkage()) {
625        case GlobalValue::LinkOnceLinkage:
626          O << ".section __TEXT,__textcoal_nt,coalesced,no_toc\n"
627            << ".weak_definition " << name << '\n'
628            << ".private_extern " << name << '\n'
629            << ".section __DATA,__datacoal_nt,coalesced,no_toc\n";
630          LinkOnceStubs.insert(name);
631          break;
632        case GlobalValue::WeakLinkage:   // FIXME: Verify correct for weak.
633          // Nonnull linkonce -> weak
634          O << "\t.weak " << name << "\n";
635          SwitchSection(O, CurSection, "");
636          O << "\t.section\t.llvm.linkonce.d." << name << ",\"aw\",@progbits\n";
637          break;
638        case GlobalValue::AppendingLinkage:
639          // FIXME: appending linkage variables should go into a section of
640          // their name or something.  For now, just emit them as external.
641        case GlobalValue::ExternalLinkage:
642          // If external or appending, declare as a global symbol
643          O << "\t.globl " << name << "\n";
644          // FALL THROUGH
645        case GlobalValue::InternalLinkage:
646          SwitchSection(O, CurSection, ".data");
647          break;
648        }
649
650        O << "\t.align " << Align << "\n";
651        O << name << ":\t\t\t\t; ";
652        WriteAsOperand(O, I, true, true, &M);
653        O << " = ";
654        WriteAsOperand(O, C, false, false, &M);
655        O << "\n";
656        emitGlobalConstant(C);
657      }
658    }
659
660  // Output stubs for link-once variables
661  if (LinkOnceStubs.begin() != LinkOnceStubs.end())
662    O << ".data\n.align 2\n";
663  for (std::set<std::string>::iterator i = LinkOnceStubs.begin(),
664         e = LinkOnceStubs.end(); i != e; ++i)
665  {
666    O << *i << "$non_lazy_ptr:\n"
667      << "\t.long\t" << *i << '\n';
668  }
669
670  // Output stubs for dynamically-linked functions
671  for (std::set<std::string>::iterator i = FnStubs.begin(), e = FnStubs.end();
672       i != e; ++i)
673  {
674    O << "\t.picsymbol_stub\n";
675    O << "L" << *i << "$stub:\n";
676    O << "\t.indirect_symbol " << *i << "\n";
677    O << "\tmflr r0\n";
678    O << "\tbl L0$" << *i << "\n";
679    O << "L0$" << *i << ":\n";
680    O << "\tmflr r11\n";
681    O << "\taddis r11,r11,ha16(L" << *i << "$lazy_ptr-L0$" << *i << ")\n";
682    O << "\tmtlr r0\n";
683    O << "\tlwz r12,lo16(L" << *i << "$lazy_ptr-L0$" << *i << ")(r11)\n";
684    O << "\tmtctr r12\n";
685    O << "\taddi r11,r11,lo16(L" << *i << "$lazy_ptr - L0$" << *i << ")\n";
686    O << "\tbctr\n";
687    O << ".data\n";
688    O << ".lazy_symbol_pointer\n";
689    O << "L" << *i << "$lazy_ptr:\n";
690    O << ".indirect_symbol " << *i << "\n";
691    O << ".long dyld_stub_binding_helper\n";
692  }
693
694  O << "\n";
695
696  // Output stubs for external global variables
697  if (GVStubs.begin() != GVStubs.end())
698    O << ".data\n\t.non_lazy_symbol_pointer\n";
699  for (std::set<std::string>::iterator i = GVStubs.begin(), e = GVStubs.end();
700       i != e; ++i) {
701    O << "L" << *i << "$non_lazy_ptr:\n";
702    O << "\t.indirect_symbol " << *i << "\n";
703    O << "\t.long\t0\n";
704  }
705
706  delete Mang;
707  return false; // success
708}
709
710} // End llvm namespace
711