PPCAsmPrinter.cpp revision 05794498d95903d22e4402d005d1f03fab3bc78a 
1//===-- PPC32/Printer.cpp - Convert X86 LLVM code to Intel 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
11// representation of machine-dependent LLVM code to Intel-format
12// assembly language. This printer is the output mechanism used
13// by `llc' and `lli -print-machineinstrs' on X86.
14//
15//===----------------------------------------------------------------------===//
16
17#define DEBUG_TYPE "asmprinter"
18#include "PowerPC.h"
19#include "PowerPCInstrInfo.h"
20#include "llvm/Constants.h"
21#include "llvm/DerivedTypes.h"
22#include "llvm/Module.h"
23#include "llvm/Assembly/Writer.h"
24#include "llvm/CodeGen/MachineConstantPool.h"
25#include "llvm/CodeGen/MachineFunctionPass.h"
26#include "llvm/CodeGen/MachineInstr.h"
27#include "llvm/Target/TargetMachine.h"
28#include "llvm/Support/Mangler.h"
29#include "Support/CommandLine.h"
30#include "Support/Debug.h"
31#include "Support/Statistic.h"
32#include "Support/StringExtras.h"
33#include <set>
34
35namespace llvm {
36
37namespace {
38  Statistic<> EmittedInsts("asm-printer", "Number of machine instrs printed");
39
40  struct Printer : public MachineFunctionPass {
41    /// Output stream on which we're printing assembly code.
42    ///
43    std::ostream &O;
44
45    /// Target machine description which we query for reg. names, data
46    /// layout, etc.
47    ///
48    TargetMachine &TM;
49
50    /// Name-mangler for global names.
51    ///
52    Mangler *Mang;
53    std::set< std::string > Stubs;
54    std::set<std::string> Strings;
55
56    Printer(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) { }
57
58    /// We name each basic block in a Function with a unique number, so
59    /// that we can consistently refer to them later. This is cleared
60    /// at the beginning of each call to runOnMachineFunction().
61    ///
62    typedef std::map<const Value *, unsigned> ValueMapTy;
63    ValueMapTy NumberForBB;
64
65    /// Cache of mangled name for current function. This is
66    /// recalculated at the beginning of each call to
67    /// runOnMachineFunction().
68    ///
69    std::string CurrentFnName;
70
71    virtual const char *getPassName() const {
72      return "PowerPC Assembly Printer";
73    }
74
75    void printMachineInstruction(const MachineInstr *MI);
76    void printOp(const MachineOperand &MO,
77		 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 X86
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 ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(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(CPR->getValue());
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 (CV->isNullValue()) {
228    O << "\t.space\t " << TD.getTypeSize(CV->getType()) << "\n";
229    return;
230  } else if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) {
231    if (isStringCompatible(CVA)) {
232      O << ".ascii";
233      printAsCString(O, CVA);
234      O << "\n";
235    } else { // Not a string.  Print the values in successive locations
236      const std::vector<Use> &constValues = CVA->getValues();
237      for (unsigned i=0; i < constValues.size(); i++)
238        emitGlobalConstant(cast<Constant>(constValues[i].get()));
239    }
240    return;
241  } else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) {
242    // Print the fields in successive locations. Pad to align if needed!
243    const StructLayout *cvsLayout = TD.getStructLayout(CVS->getType());
244    const std::vector<Use>& constValues = CVS->getValues();
245    unsigned sizeSoFar = 0;
246    for (unsigned i=0, N = constValues.size(); i < N; i++) {
247      const Constant* field = cast<Constant>(constValues[i].get());
248
249      // Check if padding is needed and insert one or more 0s.
250      unsigned fieldSize = TD.getTypeSize(field->getType());
251      unsigned padSize = ((i == N-1? cvsLayout->StructSize
252                           : cvsLayout->MemberOffsets[i+1])
253                          - cvsLayout->MemberOffsets[i]) - fieldSize;
254      sizeSoFar += fieldSize + padSize;
255
256      // Now print the actual field value
257      emitGlobalConstant(field);
258
259      // Insert the field padding unless it's zero bytes...
260      if (padSize)
261        O << "\t.space\t " << padSize << "\n";
262    }
263    assert(sizeSoFar == cvsLayout->StructSize &&
264           "Layout of constant struct may be incorrect!");
265    return;
266  } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
267    // FP Constants are printed as integer constants to avoid losing
268    // precision...
269    double Val = CFP->getValue();
270    switch (CFP->getType()->getTypeID()) {
271    default: assert(0 && "Unknown floating point type!");
272    case Type::FloatTyID: {
273      union FU {                            // Abide by C TBAA rules
274        float FVal;
275        unsigned UVal;
276      } U;
277      U.FVal = Val;
278      O << ".long\t" << U.UVal << "\t# float " << Val << "\n";
279      return;
280    }
281    case Type::DoubleTyID: {
282      union DU {                            // Abide by C TBAA rules
283        double FVal;
284        uint64_t UVal;
285        struct {
286        	uint32_t MSWord;
287        	uint32_t LSWord;
288        } T;
289      } U;
290      U.FVal = Val;
291
292      O << ".long\t" << U.T.MSWord << "\t# double most significant word " << Val << "\n";
293      O << ".long\t" << U.T.LSWord << "\t# double least significant word" << Val << "\n";
294      return;
295    }
296    }
297  } else if (CV->getType()->getPrimitiveSize() == 64) {
298    const ConstantInt *CI = dyn_cast<ConstantInt>(CV);
299    if(CI) {
300  	union DU {                            // Abide by C TBAA rules
301        int64_t UVal;
302        struct {
303        	uint32_t MSWord;
304        	uint32_t LSWord;
305        } T;
306      } U;
307      U.UVal = CI->getRawValue();
308
309      O << ".long\t" << U.T.MSWord << "\t# Double-word most significant word " << U.UVal << "\n";
310      O << ".long\t" << U.T.LSWord << "\t# Double-word least significant word" << 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    assert (0 && "Can't handle printing this type of thing");
335    break;
336  }
337  O << "\t";
338  emitConstantValueOnly(CV);
339  O << "\n";
340}
341
342/// printConstantPool - Print to the current output stream assembly
343/// representations of the constants in the constant pool MCP. This is
344/// used to print out constants which have been "spilled to memory" by
345/// the code generator.
346///
347void Printer::printConstantPool(MachineConstantPool *MCP) {
348  const std::vector<Constant*> &CP = MCP->getConstants();
349  const TargetData &TD = TM.getTargetData();
350
351  if (CP.empty()) return;
352
353  for (unsigned i = 0, e = CP.size(); i != e; ++i) {
354    O << "\t.const\n";
355    O << "\t.align " << (unsigned)TD.getTypeAlignment(CP[i]->getType())
356      << "\n";
357    O << ".CPI" << CurrentFnName << "_" << i << ":\t\t\t\t\t#"
358      << *CP[i] << "\n";
359    emitGlobalConstant(CP[i]);
360  }
361}
362
363/// runOnMachineFunction - This uses the printMachineInstruction()
364/// method to print assembly for each instruction.
365///
366bool Printer::runOnMachineFunction(MachineFunction &MF) {
367  // BBNumber is used here so that a given Printer will never give two
368  // BBs the same name. (If you have a better way, please let me know!)
369  static unsigned BBNumber = 0;
370
371  O << "\n\n";
372  // What's my mangled name?
373  CurrentFnName = Mang->getValueName(MF.getFunction());
374
375  // Print out constants referenced by the function
376  printConstantPool(MF.getConstantPool());
377
378  // Print out labels for the function.
379  O << "\t.text\n";
380  O << "\t.globl\t" << CurrentFnName << "\n";
381  O << "\t.align 5\n";
382  O << CurrentFnName << ":\n";
383
384  // Number each basic block so that we can consistently refer to them
385  // in PC-relative references.
386  NumberForBB.clear();
387  for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
388       I != E; ++I) {
389    NumberForBB[I->getBasicBlock()] = BBNumber++;
390  }
391
392  // Print out code for the function.
393  for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
394       I != E; ++I) {
395    // Print a label for the basic block.
396    O << "L" << NumberForBB[I->getBasicBlock()] << ":\t# "
397      << I->getBasicBlock()->getName() << "\n";
398    for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
399	 II != E; ++II) {
400      // Print the assembly for the instruction.
401      O << "\t";
402      printMachineInstruction(II);
403    }
404  }
405
406  // We didn't modify anything.
407  return false;
408}
409
410
411
412void Printer::printOp(const MachineOperand &MO,
413		      bool elideOffsetKeyword /* = false */) {
414  const MRegisterInfo &RI = *TM.getRegisterInfo();
415  int new_symbol;
416
417  switch (MO.getType()) {
418  case MachineOperand::MO_VirtualRegister:
419    if (Value *V = MO.getVRegValueOrNull()) {
420      O << "<" << V->getName() << ">";
421      return;
422    }
423    // FALLTHROUGH
424  case MachineOperand::MO_MachineRegister:
425      O << RI.get(MO.getReg()).Name;
426      return;
427
428  case MachineOperand::MO_SignExtendedImmed:
429  case MachineOperand::MO_UnextendedImmed:
430    O << (int)MO.getImmedValue();
431    return;
432  case MachineOperand::MO_MachineBasicBlock: {
433    MachineBasicBlock *MBBOp = MO.getMachineBasicBlock();
434    O << ".LBB" << Mang->getValueName(MBBOp->getParent()->getFunction())
435      << "_" << MBBOp->getNumber () << "\t# "
436      << MBBOp->getBasicBlock ()->getName ();
437    return;
438  }
439  case MachineOperand::MO_PCRelativeDisp:
440    std::cerr << "Shouldn't use addPCDisp() when building PPC MachineInstrs";
441    abort ();
442    return;
443  case MachineOperand::MO_GlobalAddress:
444    if (!elideOffsetKeyword) {
445		if(isa<Function>(MO.getGlobal())) {
446			Stubs.insert(Mang->getValueName(MO.getGlobal()));
447			O << "L" << Mang->getValueName(MO.getGlobal()) << "$stub";
448		} else {
449			O << Mang->getValueName(MO.getGlobal());
450		}
451    }
452    return;
453  case MachineOperand::MO_ExternalSymbol:
454    O << MO.getSymbolName();
455    return;
456  default:
457    O << "<unknown operand type>"; return;
458  }
459}
460
461#if 0
462static inline
463unsigned int ValidOpcodes(const MachineInstr *MI, unsigned int ArgType[5]) {
464	int i;
465	unsigned int retval = 1;
466
467	for(i = 0; i<5; i++) {
468		switch(ArgType[i]) {
469			case none:
470				break;
471			case Gpr:
472			case Gpr0:
473				Type::UIntTy
474			case Simm16:
475			case Zimm16:
476			case PCRelimm24:
477			case Imm24:
478			case Imm5:
479			case PCRelimm14:
480			case Imm14:
481			case Imm2:
482			case Crf:
483			case Imm3:
484			case Imm1:
485			case Fpr:
486			case Imm4:
487			case Imm8:
488			case Disimm16:
489			case Spr:
490			case Sgr:
491	};
492
493		}
494	}
495}
496#endif
497
498/// printMachineInstruction -- Print out a single PPC32 LLVM instruction
499/// MI in Darwin syntax to the current output stream.
500///
501void Printer::printMachineInstruction(const MachineInstr *MI) {
502  unsigned Opcode = MI->getOpcode();
503  const TargetInstrInfo &TII = *TM.getInstrInfo();
504  const TargetInstrDescriptor &Desc = TII.get(Opcode);
505  unsigned int i;
506
507  unsigned int ArgCount = Desc.TSFlags & PPC32II::ArgCountMask;
508  unsigned int ArgType[5];
509
510
511  ArgType[0] = (Desc.TSFlags>>PPC32II::Arg0TypeShift) & PPC32II::ArgTypeMask;
512  ArgType[1] = (Desc.TSFlags>>PPC32II::Arg1TypeShift) & PPC32II::ArgTypeMask;
513  ArgType[2] = (Desc.TSFlags>>PPC32II::Arg2TypeShift) & PPC32II::ArgTypeMask;
514  ArgType[3] = (Desc.TSFlags>>PPC32II::Arg3TypeShift) & PPC32II::ArgTypeMask;
515  ArgType[4] = (Desc.TSFlags>>PPC32II::Arg4TypeShift) & PPC32II::ArgTypeMask;
516
517  assert ( ((Desc.TSFlags & PPC32II::VMX) == 0) && "Instruction requires VMX support");
518  assert ( ((Desc.TSFlags & PPC32II::PPC64) == 0) && "Instruction requires 64 bit support");
519  //assert ( ValidOpcodes(MI, ArgType) && "Instruction has invalid inputs");
520  ++EmittedInsts;
521
522  if(Opcode == PPC32::MovePCtoLR) {
523    O << "mflr r0\n";
524    O << "bcl 20,31,L" << CurrentFnName << "$pb\n";
525    O  << "L" << CurrentFnName << "$pb:\n";
526    return;
527  }
528
529  O << TII.getName(MI->getOpcode()) << " ";
530  DEBUG(std::cerr << TII.getName(MI->getOpcode()) << " expects "
531                  << ArgCount << " args\n");
532
533  if(Opcode == PPC32::LOADLoAddr) {
534    printOp(MI->getOperand(0));
535    O << ", ";
536    printOp(MI->getOperand(1));
537    O << ", lo16(";
538    printOp(MI->getOperand(2));
539    O << "-L" << CurrentFnName << "$pb)\n";
540    return;
541  }
542
543  if(Opcode == PPC32::LOADHiAddr) {
544    printOp(MI->getOperand(0));
545    O << ", ";
546    printOp(MI->getOperand(1));
547    O << ", ha16(" ;
548    printOp(MI->getOperand(2));
549     O << "-L" << CurrentFnName << "$pb)\n";
550    return;
551  }
552
553  if( (ArgCount == 3) && (ArgType[1] == PPC32II::Disimm16) ) {
554    printOp(MI->getOperand(0));
555    O << ", ";
556    printOp(MI->getOperand(1));
557    O << "(";
558    if((ArgType[2] == PPC32II::Gpr0) && (MI->getOperand(2).getReg() == PPC32::R0)) {
559    	O << "0";
560    } else {
561    	printOp(MI->getOperand(2));
562    }
563    O << ")\n";
564  } else {
565    for(i = 0; i< ArgCount; i++) {
566        if( (ArgType[i] == PPC32II::Gpr0) && ((MI->getOperand(i).getReg()) == PPC32::R0)) {
567            O << "0";
568        } else {
569        	//std::cout << "DEBUG " << (*(TM.getRegisterInfo())).get(MI->getOperand(i).getReg()).Name << "\n";
570            printOp(MI->getOperand(i));
571        }
572        if( ArgCount - 1 == i) {
573            O << "\n";
574        } else {
575            O << ", ";
576        }
577    }
578  }
579
580  return;
581}
582
583bool Printer::doInitialization(Module &M) {
584  // Tell gas we are outputting Intel syntax (not AT&T syntax) assembly.
585  //
586  // Bug: gas in `intel_syntax noprefix' mode interprets the symbol `Sp' in an
587  // instruction as a reference to the register named sp, and if you try to
588  // reference a symbol `Sp' (e.g. `mov ECX, OFFSET Sp') then it gets lowercased
589  // before being looked up in the symbol table. This creates spurious
590  // `undefined symbol' errors when linking. Workaround: Do not use `noprefix'
591  // mode, and decorate all register names with percent signs.
592 // O << "\t.intel_syntax\n";
593  Mang = new Mangler(M, true);
594  return false; // success
595}
596
597// SwitchSection - Switch to the specified section of the executable if we are
598// not already in it!
599//
600static void SwitchSection(std::ostream &OS, std::string &CurSection,
601                          const char *NewSection) {
602  if (CurSection != NewSection) {
603    CurSection = NewSection;
604    if (!CurSection.empty())
605      OS << "\t" << NewSection << "\n";
606  }
607}
608
609bool Printer::doFinalization(Module &M) {
610  const TargetData &TD = TM.getTargetData();
611  std::string CurSection;
612
613  // Print out module-level global variables here.
614  for (Module::const_giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
615    if (I->hasInitializer()) {   // External global require no code
616      O << "\n\n";
617      std::string name = Mang->getValueName(I);
618      Constant *C = I->getInitializer();
619      unsigned Size = TD.getTypeSize(C->getType());
620      unsigned Align = TD.getTypeAlignment(C->getType());
621
622      if (C->isNullValue() &&
623          (I->hasLinkOnceLinkage() || I->hasInternalLinkage() ||
624           I->hasWeakLinkage() /* FIXME: Verify correct */)) {
625        SwitchSection(O, CurSection, ".data");
626        if (I->hasInternalLinkage())
627          O << "\t.local " << name << "\n";
628
629        O << "\t.comm " << name << "," << TD.getTypeSize(C->getType())
630          << "," << (unsigned)TD.getTypeAlignment(C->getType());
631        O << "\t\t# ";
632        WriteAsOperand(O, I, true, true, &M);
633        O << "\n";
634      } else {
635        switch (I->getLinkage()) {
636        case GlobalValue::LinkOnceLinkage:
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
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          if (C->isNullValue())
653            SwitchSection(O, CurSection, ".bss");
654          else
655            SwitchSection(O, CurSection, ".data");
656          break;
657        }
658
659        O << "\t.align " << Align << "\n";
660        O << name << ":\t\t\t\t# ";
661        WriteAsOperand(O, I, true, true, &M);
662        O << " = ";
663        WriteAsOperand(O, C, false, false, &M);
664        O << "\n";
665        emitGlobalConstant(C);
666      }
667    }
668
669    for(std::set<std::string>::iterator i = Stubs.begin(); i != Stubs.end(); ++i) {
670    	O << ".data\n";
671		O << ".section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32\n";
672		O << "\t.align 2\n";
673    	O << "L" << *i << "$stub:\n";
674    	O << "\t.indirect_symbol " << *i << "\n";
675    	O << "\tmflr r0\n";
676    	O << "\tbcl 20,31,L0$" << *i << "\n";
677    	O << "L0$" << *i << ":\n";
678    	O << "\tmflr r11\n";
679    	O << "\taddis r11,r11,ha16(L" << *i << "$lazy_ptr-L0$" << *i << ")\n";
680    	O << "\tmtlr r0\n";
681    	O << "\tlwzu r12,lo16(L" << *i << "$lazy_ptr-L0$" << *i << ")(r11)\n";
682    	O << "\tmtctr r12\n";
683    	O << "\tbctr\n";
684    	O << ".data\n";
685		O << ".lazy_symbol_pointer\n";
686		O << "L" << *i << "$lazy_ptr:\n";
687        O << ".indirect_symbol " << *i << "\n";
688        O << ".long dyld_stub_binding_helper\n";
689
690   	}
691
692  delete Mang;
693  return false; // success
694}
695
696} // End llvm namespace
697