PPCAsmPrinter.cpp revision cf8d24439458ac77e3d3565b51964e0a8802b339 
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
38namespace llvm {
39
40namespace {
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///
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  ++LabelNumber;
399
400  // We didn't modify anything.
401  return false;
402}
403
404void 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///
485void 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    O << "(";
544    if (MI->getOperand(1).getReg() == PPC32::R0)
545      O << "0";
546    else
547      printOp(MI->getOperand(1));
548    O << ")\n";
549  } else if (Opcode == PPC32::LOADHiAddr) {
550    printOp(MI->getOperand(0));
551    O << ", ";
552    if (MI->getOperand(1).getReg() == PPC32::R0)
553      O << "0";
554    else
555      printOp(MI->getOperand(1));
556    O << ", ha16(" ;
557    printOp(MI->getOperand(2));
558     O << "-\"L0000" << LabelNumber << "$pb\")\n";
559  } else if (ArgCount == 3 && ArgType[1] == PPC32II::Disimm16) {
560    printOp(MI->getOperand(0));
561    O << ", ";
562    printOp(MI->getOperand(1));
563    O << "(";
564    if (MI->getOperand(2).hasAllocatedReg() &&
565        MI->getOperand(2).getReg() == PPC32::R0)
566      O << "0";
567    else
568      printOp(MI->getOperand(2));
569    O << ")\n";
570  } else {
571    for (i = 0; i < ArgCount; ++i) {
572      if (i == 1 && ArgCount == 3 && ArgType[2] == PPC32II::Simm16 &&
573          MI->getOperand(1).hasAllocatedReg() &&
574          MI->getOperand(1).getReg() == PPC32::R0) {
575        O << "0";
576      } else {
577        printOp(MI->getOperand(i));
578      }
579      if (ArgCount - 1 == i)
580        O << "\n";
581      else
582        O << ", ";
583    }
584  }
585}
586
587bool Printer::doInitialization(Module &M) {
588  Mang = new Mangler(M, true);
589  return false; // success
590}
591
592// SwitchSection - Switch to the specified section of the executable if we are
593// not already in it!
594//
595static void SwitchSection(std::ostream &OS, std::string &CurSection,
596                          const char *NewSection) {
597  if (CurSection != NewSection) {
598    CurSection = NewSection;
599    if (!CurSection.empty())
600      OS << "\t" << NewSection << "\n";
601  }
602}
603
604bool Printer::doFinalization(Module &M) {
605  const TargetData &TD = TM.getTargetData();
606  std::string CurSection;
607
608  // Print out module-level global variables here.
609  for (Module::const_giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
610    if (I->hasInitializer()) {   // External global require no code
611      O << "\n\n";
612      std::string name = Mang->getValueName(I);
613      Constant *C = I->getInitializer();
614      unsigned Size = TD.getTypeSize(C->getType());
615      unsigned Align = TD.getTypeAlignment(C->getType());
616
617      if (C->isNullValue() && /* FIXME: Verify correct */
618          (I->hasInternalLinkage() || I->hasWeakLinkage())) {
619        SwitchSection(O, CurSection, ".data");
620        if (I->hasInternalLinkage())
621          O << ".lcomm " << name << "," << TD.getTypeSize(C->getType())
622            << "," << (unsigned)TD.getTypeAlignment(C->getType());
623        else
624          O << ".comm " << name << "," << TD.getTypeSize(C->getType());
625        O << "\t\t; ";
626        WriteAsOperand(O, I, true, true, &M);
627        O << "\n";
628      } else {
629        switch (I->getLinkage()) {
630        case GlobalValue::LinkOnceLinkage:
631          O << ".section __TEXT,__textcoal_nt,coalesced,no_toc\n"
632            << ".weak_definition " << name << '\n'
633            << ".private_extern " << name << '\n'
634            << ".section __DATA,__datacoal_nt,coalesced,no_toc\n";
635          LinkOnceStubs.insert(name);
636          break;
637        case GlobalValue::WeakLinkage:   // FIXME: Verify correct for weak.
638          // Nonnull linkonce -> weak
639          O << "\t.weak " << name << "\n";
640          SwitchSection(O, CurSection, "");
641          O << "\t.section\t.llvm.linkonce.d." << name << ",\"aw\",@progbits\n";
642          break;
643        case GlobalValue::AppendingLinkage:
644          // FIXME: appending linkage variables should go into a section of
645          // their name or something.  For now, just emit them as external.
646        case GlobalValue::ExternalLinkage:
647          // If external or appending, declare as a global symbol
648          O << "\t.globl " << name << "\n";
649          // FALL THROUGH
650        case GlobalValue::InternalLinkage:
651          SwitchSection(O, CurSection, ".data");
652          break;
653        }
654
655        O << "\t.align " << Align << "\n";
656        O << name << ":\t\t\t\t; ";
657        WriteAsOperand(O, I, true, true, &M);
658        O << " = ";
659        WriteAsOperand(O, C, false, false, &M);
660        O << "\n";
661        emitGlobalConstant(C);
662      }
663    }
664
665  // Output stubs for link-once variables
666  if (LinkOnceStubs.begin() != LinkOnceStubs.end())
667    O << ".data\n.align 2\n";
668  for (std::set<std::string>::iterator i = LinkOnceStubs.begin(),
669         e = LinkOnceStubs.end(); i != e; ++i) {
670    O << *i << "$non_lazy_ptr:\n"
671      << "\t.long\t" << *i << '\n';
672  }
673
674  // Output stubs for dynamically-linked functions
675  for (std::set<std::string>::iterator i = FnStubs.begin(), e = FnStubs.end();
676       i != e; ++i)
677  {
678    O << ".data\n";
679    O << ".section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32\n";
680    O << "\t.align 2\n";
681    O << "L" << *i << "$stub:\n";
682    O << "\t.indirect_symbol " << *i << "\n";
683    O << "\tmflr r0\n";
684    O << "\tbcl 20,31,L0$" << *i << "\n";
685    O << "L0$" << *i << ":\n";
686    O << "\tmflr r11\n";
687    O << "\taddis r11,r11,ha16(L" << *i << "$lazy_ptr-L0$" << *i << ")\n";
688    O << "\tmtlr r0\n";
689    O << "\tlwzu r12,lo16(L" << *i << "$lazy_ptr-L0$" << *i << ")(r11)\n";
690    O << "\tmtctr r12\n";
691    O << "\tbctr\n";
692    O << ".data\n";
693    O << ".lazy_symbol_pointer\n";
694    O << "L" << *i << "$lazy_ptr:\n";
695    O << "\t.indirect_symbol " << *i << "\n";
696    O << "\t.long dyld_stub_binding_helper\n";
697  }
698
699  O << "\n";
700
701  // Output stubs for external global variables
702  if (GVStubs.begin() != GVStubs.end())
703    O << ".data\n.non_lazy_symbol_pointer\n";
704  for (std::set<std::string>::iterator i = GVStubs.begin(), e = GVStubs.end();
705       i != e; ++i) {
706    O << "L" << *i << "$non_lazy_ptr:\n";
707    O << "\t.indirect_symbol " << *i << "\n";
708    O << "\t.long\t0\n";
709  }
710
711  delete Mang;
712  return false; // success
713}
714
715} // End llvm namespace
716