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