AsmWriter.cpp revision 9a40c023ccfe28cbaf4f6b2c92f033f2d6536231
1//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 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 library implements the functionality defined in llvm/Assembly/Writer.h 11// 12// Note that these routines must be extremely tolerant of various errors in the 13// LLVM code, because it can be used for debugging transformations. 14// 15//===----------------------------------------------------------------------===// 16 17#include "llvm/Assembly/Writer.h" 18#include "llvm/Assembly/PrintModulePass.h" 19#include "llvm/Assembly/AsmAnnotationWriter.h" 20#include "llvm/CallingConv.h" 21#include "llvm/Constants.h" 22#include "llvm/DerivedTypes.h" 23#include "llvm/InlineAsm.h" 24#include "llvm/Instruction.h" 25#include "llvm/Instructions.h" 26#include "llvm/Module.h" 27#include "llvm/SymbolTable.h" 28#include "llvm/TypeSymbolTable.h" 29#include "llvm/ADT/StringExtras.h" 30#include "llvm/ADT/STLExtras.h" 31#include "llvm/Support/CFG.h" 32#include "llvm/Support/MathExtras.h" 33#include "llvm/Support/Streams.h" 34#include <algorithm> 35using namespace llvm; 36 37namespace llvm { 38 39// Make virtual table appear in this compilation unit. 40AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {} 41 42/// This class provides computation of slot numbers for LLVM Assembly writing. 43/// @brief LLVM Assembly Writing Slot Computation. 44class SlotMachine { 45 46/// @name Types 47/// @{ 48public: 49 50 /// @brief A mapping of Values to slot numbers 51 typedef std::map<const Value*, unsigned> ValueMap; 52 53 /// @brief A plane with next slot number and ValueMap 54 struct ValuePlane { 55 unsigned next_slot; ///< The next slot number to use 56 ValueMap map; ///< The map of Value* -> unsigned 57 ValuePlane() { next_slot = 0; } ///< Make sure we start at 0 58 }; 59 60 /// @brief The map of planes by Type 61 typedef std::map<const Type*, ValuePlane> TypedPlanes; 62 63/// @} 64/// @name Constructors 65/// @{ 66public: 67 /// @brief Construct from a module 68 SlotMachine(const Module *M); 69 70 /// @brief Construct from a function, starting out in incorp state. 71 SlotMachine(const Function *F); 72 73/// @} 74/// @name Accessors 75/// @{ 76public: 77 /// Return the slot number of the specified value in it's type 78 /// plane. If something is not in the SlotMachine, return -1. 79 int getLocalSlot(const Value *V); 80 int getGlobalSlot(const GlobalValue *V); 81 82/// @} 83/// @name Mutators 84/// @{ 85public: 86 /// If you'd like to deal with a function instead of just a module, use 87 /// this method to get its data into the SlotMachine. 88 void incorporateFunction(const Function *F) { 89 TheFunction = F; 90 FunctionProcessed = false; 91 } 92 93 /// After calling incorporateFunction, use this method to remove the 94 /// most recently incorporated function from the SlotMachine. This 95 /// will reset the state of the machine back to just the module contents. 96 void purgeFunction(); 97 98/// @} 99/// @name Implementation Details 100/// @{ 101private: 102 /// This function does the actual initialization. 103 inline void initialize(); 104 105 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. 106 void CreateModuleSlot(const GlobalValue *V); 107 108 /// CreateFunctionSlot - Insert the specified Value* into the slot table. 109 void CreateFunctionSlot(const Value *V); 110 111 /// Add all of the module level global variables (and their initializers) 112 /// and function declarations, but not the contents of those functions. 113 void processModule(); 114 115 /// Add all of the functions arguments, basic blocks, and instructions 116 void processFunction(); 117 118 SlotMachine(const SlotMachine &); // DO NOT IMPLEMENT 119 void operator=(const SlotMachine &); // DO NOT IMPLEMENT 120 121/// @} 122/// @name Data 123/// @{ 124public: 125 126 /// @brief The module for which we are holding slot numbers 127 const Module* TheModule; 128 129 /// @brief The function for which we are holding slot numbers 130 const Function* TheFunction; 131 bool FunctionProcessed; 132 133 /// @brief The TypePlanes map for the module level data 134 TypedPlanes mMap; 135 136 /// @brief The TypePlanes map for the function level data 137 TypedPlanes fMap; 138 139/// @} 140 141}; 142 143} // end namespace llvm 144 145static RegisterPass<PrintModulePass> 146X("printm", "Print module to stderr"); 147static RegisterPass<PrintFunctionPass> 148Y("print","Print function to stderr"); 149 150static void WriteAsOperandInternal(std::ostream &Out, const Value *V, 151 std::map<const Type *, std::string> &TypeTable, 152 SlotMachine *Machine); 153 154static const Module *getModuleFromVal(const Value *V) { 155 if (const Argument *MA = dyn_cast<Argument>(V)) 156 return MA->getParent() ? MA->getParent()->getParent() : 0; 157 else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 158 return BB->getParent() ? BB->getParent()->getParent() : 0; 159 else if (const Instruction *I = dyn_cast<Instruction>(V)) { 160 const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 161 return M ? M->getParent() : 0; 162 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 163 return GV->getParent(); 164 return 0; 165} 166 167static SlotMachine *createSlotMachine(const Value *V) { 168 if (const Argument *FA = dyn_cast<Argument>(V)) { 169 return new SlotMachine(FA->getParent()); 170 } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 171 return new SlotMachine(I->getParent()->getParent()); 172 } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 173 return new SlotMachine(BB->getParent()); 174 } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 175 return new SlotMachine(GV->getParent()); 176 } else if (const Function *Func = dyn_cast<Function>(V)) { 177 return new SlotMachine(Func); 178 } 179 return 0; 180} 181 182// getLLVMName - Turn the specified string into an 'LLVM name', which is either 183// prefixed with % (if the string only contains simple characters) or is 184// surrounded with ""'s (if it has special chars in it). 185static std::string getLLVMName(const std::string &Name, 186 bool prefixName = true) { 187 assert(!Name.empty() && "Cannot get empty name!"); 188 189 // First character cannot start with a number... 190 if (Name[0] >= '0' && Name[0] <= '9') 191 return "\"" + Name + "\""; 192 193 // Scan to see if we have any characters that are not on the "white list" 194 for (unsigned i = 0, e = Name.size(); i != e; ++i) { 195 char C = Name[i]; 196 assert(C != '"' && "Illegal character in LLVM value name!"); 197 if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') && 198 C != '-' && C != '.' && C != '_') 199 return "\"" + Name + "\""; 200 } 201 202 // If we get here, then the identifier is legal to use as a "VarID". 203 if (prefixName) 204 return "%"+Name; 205 else 206 return Name; 207} 208 209 210/// fillTypeNameTable - If the module has a symbol table, take all global types 211/// and stuff their names into the TypeNames map. 212/// 213static void fillTypeNameTable(const Module *M, 214 std::map<const Type *, std::string> &TypeNames) { 215 if (!M) return; 216 const TypeSymbolTable &ST = M->getTypeSymbolTable(); 217 TypeSymbolTable::const_iterator TI = ST.begin(); 218 for (; TI != ST.end(); ++TI) { 219 // As a heuristic, don't insert pointer to primitive types, because 220 // they are used too often to have a single useful name. 221 // 222 const Type *Ty = cast<Type>(TI->second); 223 if (!isa<PointerType>(Ty) || 224 !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() || 225 !cast<PointerType>(Ty)->getElementType()->isInteger() || 226 isa<OpaqueType>(cast<PointerType>(Ty)->getElementType())) 227 TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first))); 228 } 229} 230 231 232 233static void calcTypeName(const Type *Ty, 234 std::vector<const Type *> &TypeStack, 235 std::map<const Type *, std::string> &TypeNames, 236 std::string & Result){ 237 if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))) { 238 Result += Ty->getDescription(); // Base case 239 return; 240 } 241 242 // Check to see if the type is named. 243 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 244 if (I != TypeNames.end()) { 245 Result += I->second; 246 return; 247 } 248 249 if (isa<OpaqueType>(Ty)) { 250 Result += "opaque"; 251 return; 252 } 253 254 // Check to see if the Type is already on the stack... 255 unsigned Slot = 0, CurSize = TypeStack.size(); 256 while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 257 258 // This is another base case for the recursion. In this case, we know 259 // that we have looped back to a type that we have previously visited. 260 // Generate the appropriate upreference to handle this. 261 if (Slot < CurSize) { 262 Result += "\\" + utostr(CurSize-Slot); // Here's the upreference 263 return; 264 } 265 266 TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 267 268 switch (Ty->getTypeID()) { 269 case Type::IntegerTyID: { 270 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 271 Result += "i" + utostr(BitWidth); 272 break; 273 } 274 case Type::FunctionTyID: { 275 const FunctionType *FTy = cast<FunctionType>(Ty); 276 calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result); 277 Result += " ("; 278 unsigned Idx = 1; 279 for (FunctionType::param_iterator I = FTy->param_begin(), 280 E = FTy->param_end(); I != E; ++I) { 281 if (I != FTy->param_begin()) 282 Result += ", "; 283 calcTypeName(*I, TypeStack, TypeNames, Result); 284 if (FTy->getParamAttrs(Idx)) { 285 Result += + " "; 286 Result += FunctionType::getParamAttrsText(FTy->getParamAttrs(Idx)); 287 } 288 Idx++; 289 } 290 if (FTy->isVarArg()) { 291 if (FTy->getNumParams()) Result += ", "; 292 Result += "..."; 293 } 294 Result += ")"; 295 if (FTy->getParamAttrs(0)) { 296 Result += " "; 297 Result += FunctionType::getParamAttrsText(FTy->getParamAttrs(0)); 298 } 299 break; 300 } 301 case Type::StructTyID: { 302 const StructType *STy = cast<StructType>(Ty); 303 if (STy->isPacked()) 304 Result += '<'; 305 Result += "{ "; 306 for (StructType::element_iterator I = STy->element_begin(), 307 E = STy->element_end(); I != E; ++I) { 308 if (I != STy->element_begin()) 309 Result += ", "; 310 calcTypeName(*I, TypeStack, TypeNames, Result); 311 } 312 Result += " }"; 313 if (STy->isPacked()) 314 Result += '>'; 315 break; 316 } 317 case Type::PointerTyID: 318 calcTypeName(cast<PointerType>(Ty)->getElementType(), 319 TypeStack, TypeNames, Result); 320 Result += "*"; 321 break; 322 case Type::ArrayTyID: { 323 const ArrayType *ATy = cast<ArrayType>(Ty); 324 Result += "[" + utostr(ATy->getNumElements()) + " x "; 325 calcTypeName(ATy->getElementType(), TypeStack, TypeNames, Result); 326 Result += "]"; 327 break; 328 } 329 case Type::PackedTyID: { 330 const PackedType *PTy = cast<PackedType>(Ty); 331 Result += "<" + utostr(PTy->getNumElements()) + " x "; 332 calcTypeName(PTy->getElementType(), TypeStack, TypeNames, Result); 333 Result += ">"; 334 break; 335 } 336 case Type::OpaqueTyID: 337 Result += "opaque"; 338 break; 339 default: 340 Result += "<unrecognized-type>"; 341 break; 342 } 343 344 TypeStack.pop_back(); // Remove self from stack... 345} 346 347 348/// printTypeInt - The internal guts of printing out a type that has a 349/// potentially named portion. 350/// 351static std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 352 std::map<const Type *, std::string> &TypeNames) { 353 // Primitive types always print out their description, regardless of whether 354 // they have been named or not. 355 // 356 if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))) 357 return Out << Ty->getDescription(); 358 359 // Check to see if the type is named. 360 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 361 if (I != TypeNames.end()) return Out << I->second; 362 363 // Otherwise we have a type that has not been named but is a derived type. 364 // Carefully recurse the type hierarchy to print out any contained symbolic 365 // names. 366 // 367 std::vector<const Type *> TypeStack; 368 std::string TypeName; 369 calcTypeName(Ty, TypeStack, TypeNames, TypeName); 370 TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 371 return (Out << TypeName); 372} 373 374 375/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 376/// type, iff there is an entry in the modules symbol table for the specified 377/// type or one of it's component types. This is slower than a simple x << Type 378/// 379std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 380 const Module *M) { 381 Out << ' '; 382 383 // If they want us to print out a type, but there is no context, we can't 384 // print it symbolically. 385 if (!M) 386 return Out << Ty->getDescription(); 387 388 std::map<const Type *, std::string> TypeNames; 389 fillTypeNameTable(M, TypeNames); 390 return printTypeInt(Out, Ty, TypeNames); 391} 392 393// PrintEscapedString - Print each character of the specified string, escaping 394// it if it is not printable or if it is an escape char. 395static void PrintEscapedString(const std::string &Str, std::ostream &Out) { 396 for (unsigned i = 0, e = Str.size(); i != e; ++i) { 397 unsigned char C = Str[i]; 398 if (isprint(C) && C != '"' && C != '\\') { 399 Out << C; 400 } else { 401 Out << '\\' 402 << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 403 << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 404 } 405 } 406} 407 408static const char *getPredicateText(unsigned predicate) { 409 const char * pred = "unknown"; 410 switch (predicate) { 411 case FCmpInst::FCMP_FALSE: pred = "false"; break; 412 case FCmpInst::FCMP_OEQ: pred = "oeq"; break; 413 case FCmpInst::FCMP_OGT: pred = "ogt"; break; 414 case FCmpInst::FCMP_OGE: pred = "oge"; break; 415 case FCmpInst::FCMP_OLT: pred = "olt"; break; 416 case FCmpInst::FCMP_OLE: pred = "ole"; break; 417 case FCmpInst::FCMP_ONE: pred = "one"; break; 418 case FCmpInst::FCMP_ORD: pred = "ord"; break; 419 case FCmpInst::FCMP_UNO: pred = "uno"; break; 420 case FCmpInst::FCMP_UEQ: pred = "ueq"; break; 421 case FCmpInst::FCMP_UGT: pred = "ugt"; break; 422 case FCmpInst::FCMP_UGE: pred = "uge"; break; 423 case FCmpInst::FCMP_ULT: pred = "ult"; break; 424 case FCmpInst::FCMP_ULE: pred = "ule"; break; 425 case FCmpInst::FCMP_UNE: pred = "une"; break; 426 case FCmpInst::FCMP_TRUE: pred = "true"; break; 427 case ICmpInst::ICMP_EQ: pred = "eq"; break; 428 case ICmpInst::ICMP_NE: pred = "ne"; break; 429 case ICmpInst::ICMP_SGT: pred = "sgt"; break; 430 case ICmpInst::ICMP_SGE: pred = "sge"; break; 431 case ICmpInst::ICMP_SLT: pred = "slt"; break; 432 case ICmpInst::ICMP_SLE: pred = "sle"; break; 433 case ICmpInst::ICMP_UGT: pred = "ugt"; break; 434 case ICmpInst::ICMP_UGE: pred = "uge"; break; 435 case ICmpInst::ICMP_ULT: pred = "ult"; break; 436 case ICmpInst::ICMP_ULE: pred = "ule"; break; 437 } 438 return pred; 439} 440 441/// @brief Internal constant writer. 442static void WriteConstantInt(std::ostream &Out, const Constant *CV, 443 std::map<const Type *, std::string> &TypeTable, 444 SlotMachine *Machine) { 445 const int IndentSize = 4; 446 static std::string Indent = "\n"; 447 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 448 if (CI->getType() == Type::Int1Ty) 449 Out << (CI->getZExtValue() ? "true" : "false"); 450 else 451 Out << CI->getSExtValue(); 452 } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 453 // We would like to output the FP constant value in exponential notation, 454 // but we cannot do this if doing so will lose precision. Check here to 455 // make sure that we only output it in exponential format if we can parse 456 // the value back and get the same value. 457 // 458 std::string StrVal = ftostr(CFP->getValue()); 459 460 // Check to make sure that the stringized number is not some string like 461 // "Inf" or NaN, that atof will accept, but the lexer will not. Check that 462 // the string matches the "[-+]?[0-9]" regex. 463 // 464 if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 465 ((StrVal[0] == '-' || StrVal[0] == '+') && 466 (StrVal[1] >= '0' && StrVal[1] <= '9'))) 467 // Reparse stringized version! 468 if (atof(StrVal.c_str()) == CFP->getValue()) { 469 Out << StrVal; 470 return; 471 } 472 473 // Otherwise we could not reparse it to exactly the same value, so we must 474 // output the string in hexadecimal format! 475 assert(sizeof(double) == sizeof(uint64_t) && 476 "assuming that double is 64 bits!"); 477 Out << "0x" << utohexstr(DoubleToBits(CFP->getValue())); 478 479 } else if (isa<ConstantAggregateZero>(CV)) { 480 Out << "zeroinitializer"; 481 } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 482 // As a special case, print the array as a string if it is an array of 483 // ubytes or an array of sbytes with positive values. 484 // 485 const Type *ETy = CA->getType()->getElementType(); 486 if (CA->isString()) { 487 Out << "c\""; 488 PrintEscapedString(CA->getAsString(), Out); 489 Out << "\""; 490 491 } else { // Cannot output in string format... 492 Out << '['; 493 if (CA->getNumOperands()) { 494 Out << ' '; 495 printTypeInt(Out, ETy, TypeTable); 496 WriteAsOperandInternal(Out, CA->getOperand(0), 497 TypeTable, Machine); 498 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 499 Out << ", "; 500 printTypeInt(Out, ETy, TypeTable); 501 WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine); 502 } 503 } 504 Out << " ]"; 505 } 506 } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 507 if (CS->getType()->isPacked()) 508 Out << '<'; 509 Out << '{'; 510 unsigned N = CS->getNumOperands(); 511 if (N) { 512 if (N > 2) { 513 Indent += std::string(IndentSize, ' '); 514 Out << Indent; 515 } else { 516 Out << ' '; 517 } 518 printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 519 520 WriteAsOperandInternal(Out, CS->getOperand(0), TypeTable, Machine); 521 522 for (unsigned i = 1; i < N; i++) { 523 Out << ", "; 524 if (N > 2) Out << Indent; 525 printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 526 527 WriteAsOperandInternal(Out, CS->getOperand(i), TypeTable, Machine); 528 } 529 if (N > 2) Indent.resize(Indent.size() - IndentSize); 530 } 531 532 Out << " }"; 533 if (CS->getType()->isPacked()) 534 Out << '>'; 535 } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) { 536 const Type *ETy = CP->getType()->getElementType(); 537 assert(CP->getNumOperands() > 0 && 538 "Number of operands for a PackedConst must be > 0"); 539 Out << '<'; 540 Out << ' '; 541 printTypeInt(Out, ETy, TypeTable); 542 WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine); 543 for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) { 544 Out << ", "; 545 printTypeInt(Out, ETy, TypeTable); 546 WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine); 547 } 548 Out << " >"; 549 } else if (isa<ConstantPointerNull>(CV)) { 550 Out << "null"; 551 552 } else if (isa<UndefValue>(CV)) { 553 Out << "undef"; 554 555 } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 556 Out << CE->getOpcodeName(); 557 if (CE->isCompare()) 558 Out << " " << getPredicateText(CE->getPredicate()); 559 Out << " ("; 560 561 for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 562 printTypeInt(Out, (*OI)->getType(), TypeTable); 563 WriteAsOperandInternal(Out, *OI, TypeTable, Machine); 564 if (OI+1 != CE->op_end()) 565 Out << ", "; 566 } 567 568 if (CE->isCast()) { 569 Out << " to "; 570 printTypeInt(Out, CE->getType(), TypeTable); 571 } 572 573 Out << ')'; 574 575 } else { 576 Out << "<placeholder or erroneous Constant>"; 577 } 578} 579 580 581/// WriteAsOperand - Write the name of the specified value out to the specified 582/// ostream. This can be useful when you just want to print int %reg126, not 583/// the whole instruction that generated it. 584/// 585static void WriteAsOperandInternal(std::ostream &Out, const Value *V, 586 std::map<const Type*, std::string> &TypeTable, 587 SlotMachine *Machine) { 588 Out << ' '; 589 if (V->hasName()) 590 Out << getLLVMName(V->getName()); 591 else { 592 const Constant *CV = dyn_cast<Constant>(V); 593 if (CV && !isa<GlobalValue>(CV)) { 594 WriteConstantInt(Out, CV, TypeTable, Machine); 595 } else if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { 596 Out << "asm "; 597 if (IA->hasSideEffects()) 598 Out << "sideeffect "; 599 Out << '"'; 600 PrintEscapedString(IA->getAsmString(), Out); 601 Out << "\", \""; 602 PrintEscapedString(IA->getConstraintString(), Out); 603 Out << '"'; 604 } else { 605 int Slot; 606 if (Machine) { 607 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 608 Slot = Machine->getGlobalSlot(GV); 609 else 610 Slot = Machine->getLocalSlot(V); 611 } else { 612 Machine = createSlotMachine(V); 613 if (Machine) { 614 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 615 Slot = Machine->getGlobalSlot(GV); 616 else 617 Slot = Machine->getLocalSlot(V); 618 } else { 619 Slot = -1; 620 } 621 delete Machine; 622 } 623 if (Slot != -1) 624 Out << '%' << Slot; 625 else 626 Out << "<badref>"; 627 } 628 } 629} 630 631/// WriteAsOperand - Write the name of the specified value out to the specified 632/// ostream. This can be useful when you just want to print int %reg126, not 633/// the whole instruction that generated it. 634/// 635std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, 636 bool PrintType, const Module *Context) { 637 std::map<const Type *, std::string> TypeNames; 638 if (Context == 0) Context = getModuleFromVal(V); 639 640 if (Context) 641 fillTypeNameTable(Context, TypeNames); 642 643 if (PrintType) 644 printTypeInt(Out, V->getType(), TypeNames); 645 646 WriteAsOperandInternal(Out, V, TypeNames, 0); 647 return Out; 648} 649 650 651namespace llvm { 652 653class AssemblyWriter { 654 std::ostream &Out; 655 SlotMachine &Machine; 656 const Module *TheModule; 657 std::map<const Type *, std::string> TypeNames; 658 AssemblyAnnotationWriter *AnnotationWriter; 659public: 660 inline AssemblyWriter(std::ostream &o, SlotMachine &Mac, const Module *M, 661 AssemblyAnnotationWriter *AAW) 662 : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) { 663 664 // If the module has a symbol table, take all global types and stuff their 665 // names into the TypeNames map. 666 // 667 fillTypeNameTable(M, TypeNames); 668 } 669 670 inline void write(const Module *M) { printModule(M); } 671 inline void write(const GlobalVariable *G) { printGlobal(G); } 672 inline void write(const Function *F) { printFunction(F); } 673 inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 674 inline void write(const Instruction *I) { printInstruction(*I); } 675 inline void write(const Constant *CPV) { printConstant(CPV); } 676 inline void write(const Type *Ty) { printType(Ty); } 677 678 void writeOperand(const Value *Op, bool PrintType); 679 680 const Module* getModule() { return TheModule; } 681 682private: 683 void printModule(const Module *M); 684 void printTypeSymbolTable(const TypeSymbolTable &ST); 685 void printValueSymbolTable(const SymbolTable &ST); 686 void printConstant(const Constant *CPV); 687 void printGlobal(const GlobalVariable *GV); 688 void printFunction(const Function *F); 689 void printArgument(const Argument *FA, FunctionType::ParameterAttributes A); 690 void printBasicBlock(const BasicBlock *BB); 691 void printInstruction(const Instruction &I); 692 693 // printType - Go to extreme measures to attempt to print out a short, 694 // symbolic version of a type name. 695 // 696 std::ostream &printType(const Type *Ty) { 697 return printTypeInt(Out, Ty, TypeNames); 698 } 699 700 // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 701 // without considering any symbolic types that we may have equal to it. 702 // 703 std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 704 705 // printInfoComment - Print a little comment after the instruction indicating 706 // which slot it occupies. 707 void printInfoComment(const Value &V); 708}; 709} // end of llvm namespace 710 711/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 712/// without considering any symbolic types that we may have equal to it. 713/// 714std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 715 if (const IntegerType *ITy = dyn_cast<IntegerType>(Ty)) 716 Out << "i" << utostr(ITy->getBitWidth()); 717 else if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 718 printType(FTy->getReturnType()); 719 Out << " ("; 720 unsigned Idx = 1; 721 for (FunctionType::param_iterator I = FTy->param_begin(), 722 E = FTy->param_end(); I != E; ++I) { 723 if (I != FTy->param_begin()) 724 Out << ", "; 725 printType(*I); 726 if (FTy->getParamAttrs(Idx)) { 727 Out << " " << FunctionType::getParamAttrsText(FTy->getParamAttrs(Idx)); 728 } 729 Idx++; 730 } 731 if (FTy->isVarArg()) { 732 if (FTy->getNumParams()) Out << ", "; 733 Out << "..."; 734 } 735 Out << ')'; 736 if (FTy->getParamAttrs(0)) 737 Out << ' ' << FunctionType::getParamAttrsText(FTy->getParamAttrs(0)); 738 } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 739 if (STy->isPacked()) 740 Out << '<'; 741 Out << "{ "; 742 for (StructType::element_iterator I = STy->element_begin(), 743 E = STy->element_end(); I != E; ++I) { 744 if (I != STy->element_begin()) 745 Out << ", "; 746 printType(*I); 747 } 748 Out << " }"; 749 if (STy->isPacked()) 750 Out << '>'; 751 } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 752 printType(PTy->getElementType()) << '*'; 753 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 754 Out << '[' << ATy->getNumElements() << " x "; 755 printType(ATy->getElementType()) << ']'; 756 } else if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 757 Out << '<' << PTy->getNumElements() << " x "; 758 printType(PTy->getElementType()) << '>'; 759 } 760 else if (isa<OpaqueType>(Ty)) { 761 Out << "opaque"; 762 } else { 763 if (!Ty->isPrimitiveType()) 764 Out << "<unknown derived type>"; 765 printType(Ty); 766 } 767 return Out; 768} 769 770 771void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) { 772 if (Operand == 0) { 773 Out << "<null operand!>"; 774 } else { 775 if (PrintType) { Out << ' '; printType(Operand->getType()); } 776 WriteAsOperandInternal(Out, Operand, TypeNames, &Machine); 777 } 778} 779 780 781void AssemblyWriter::printModule(const Module *M) { 782 if (!M->getModuleIdentifier().empty() && 783 // Don't print the ID if it will start a new line (which would 784 // require a comment char before it). 785 M->getModuleIdentifier().find('\n') == std::string::npos) 786 Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; 787 788 if (!M->getDataLayout().empty()) 789 Out << "target datalayout = \"" << M->getDataLayout() << "\"\n"; 790 791 switch (M->getEndianness()) { 792 case Module::LittleEndian: Out << "target endian = little\n"; break; 793 case Module::BigEndian: Out << "target endian = big\n"; break; 794 case Module::AnyEndianness: break; 795 } 796 switch (M->getPointerSize()) { 797 case Module::Pointer32: Out << "target pointersize = 32\n"; break; 798 case Module::Pointer64: Out << "target pointersize = 64\n"; break; 799 case Module::AnyPointerSize: break; 800 } 801 if (!M->getTargetTriple().empty()) 802 Out << "target triple = \"" << M->getTargetTriple() << "\"\n"; 803 804 if (!M->getModuleInlineAsm().empty()) { 805 // Split the string into lines, to make it easier to read the .ll file. 806 std::string Asm = M->getModuleInlineAsm(); 807 size_t CurPos = 0; 808 size_t NewLine = Asm.find_first_of('\n', CurPos); 809 while (NewLine != std::string::npos) { 810 // We found a newline, print the portion of the asm string from the 811 // last newline up to this newline. 812 Out << "module asm \""; 813 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine), 814 Out); 815 Out << "\"\n"; 816 CurPos = NewLine+1; 817 NewLine = Asm.find_first_of('\n', CurPos); 818 } 819 Out << "module asm \""; 820 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out); 821 Out << "\"\n"; 822 } 823 824 // Loop over the dependent libraries and emit them. 825 Module::lib_iterator LI = M->lib_begin(); 826 Module::lib_iterator LE = M->lib_end(); 827 if (LI != LE) { 828 Out << "deplibs = [ "; 829 while (LI != LE) { 830 Out << '"' << *LI << '"'; 831 ++LI; 832 if (LI != LE) 833 Out << ", "; 834 } 835 Out << " ]\n"; 836 } 837 838 // Loop over the symbol table, emitting all named constants. 839 printTypeSymbolTable(M->getTypeSymbolTable()); 840 printValueSymbolTable(M->getValueSymbolTable()); 841 842 for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); 843 I != E; ++I) 844 printGlobal(I); 845 846 Out << "\nimplementation ; Functions:\n"; 847 848 // Output all of the functions. 849 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 850 printFunction(I); 851} 852 853void AssemblyWriter::printGlobal(const GlobalVariable *GV) { 854 if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = "; 855 856 if (!GV->hasInitializer()) 857 switch (GV->getLinkage()) { 858 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 859 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 860 default: Out << "external "; break; 861 } else { 862 switch (GV->getLinkage()) { 863 case GlobalValue::InternalLinkage: Out << "internal "; break; 864 case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 865 case GlobalValue::WeakLinkage: Out << "weak "; break; 866 case GlobalValue::AppendingLinkage: Out << "appending "; break; 867 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 868 case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 869 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 870 case GlobalValue::ExternalLinkage: break; 871 case GlobalValue::GhostLinkage: 872 cerr << "GhostLinkage not allowed in AsmWriter!\n"; 873 abort(); 874 } 875 switch (GV->getVisibility()) { 876 default: assert(0 && "Invalid visibility style!"); 877 case GlobalValue::DefaultVisibility: break; 878 case GlobalValue::HiddenVisibility: Out << "hidden "; break; 879 } 880 } 881 882 Out << (GV->isConstant() ? "constant " : "global "); 883 printType(GV->getType()->getElementType()); 884 885 if (GV->hasInitializer()) { 886 Constant* C = cast<Constant>(GV->getInitializer()); 887 assert(C && "GlobalVar initializer isn't constant?"); 888 writeOperand(GV->getInitializer(), false); 889 } 890 891 if (GV->hasSection()) 892 Out << ", section \"" << GV->getSection() << '"'; 893 if (GV->getAlignment()) 894 Out << ", align " << GV->getAlignment(); 895 896 printInfoComment(*GV); 897 Out << "\n"; 898} 899 900void AssemblyWriter::printTypeSymbolTable(const TypeSymbolTable &ST) { 901 // Print the types. 902 for (TypeSymbolTable::const_iterator TI = ST.begin(), TE = ST.end(); 903 TI != TE; ++TI) { 904 Out << "\t" << getLLVMName(TI->first) << " = type "; 905 906 // Make sure we print out at least one level of the type structure, so 907 // that we do not get %FILE = type %FILE 908 // 909 printTypeAtLeastOneLevel(TI->second) << "\n"; 910 } 911} 912 913// printSymbolTable - Run through symbol table looking for constants 914// and types. Emit their declarations. 915void AssemblyWriter::printValueSymbolTable(const SymbolTable &ST) { 916 917 // Print the constants, in type plane order. 918 for (SymbolTable::plane_const_iterator PI = ST.plane_begin(); 919 PI != ST.plane_end(); ++PI) { 920 SymbolTable::value_const_iterator VI = ST.value_begin(PI->first); 921 SymbolTable::value_const_iterator VE = ST.value_end(PI->first); 922 923 for (; VI != VE; ++VI) { 924 const Value* V = VI->second; 925 const Constant *CPV = dyn_cast<Constant>(V) ; 926 if (CPV && !isa<GlobalValue>(V)) { 927 printConstant(CPV); 928 } 929 } 930 } 931} 932 933 934/// printConstant - Print out a constant pool entry... 935/// 936void AssemblyWriter::printConstant(const Constant *CPV) { 937 // Don't print out unnamed constants, they will be inlined 938 if (!CPV->hasName()) return; 939 940 // Print out name... 941 Out << "\t" << getLLVMName(CPV->getName()) << " ="; 942 943 // Write the value out now. 944 writeOperand(CPV, true); 945 946 printInfoComment(*CPV); 947 Out << "\n"; 948} 949 950/// printFunction - Print all aspects of a function. 951/// 952void AssemblyWriter::printFunction(const Function *F) { 953 // Print out the return type and name... 954 Out << "\n"; 955 956 // Ensure that no local symbols conflict with global symbols. 957 const_cast<Function*>(F)->renameLocalSymbols(); 958 959 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); 960 961 if (F->isExternal()) 962 switch (F->getLinkage()) { 963 case GlobalValue::DLLImportLinkage: Out << "declare dllimport "; break; 964 case GlobalValue::ExternalWeakLinkage: Out << "declare extern_weak "; break; 965 default: Out << "declare "; 966 } 967 else { 968 Out << "define "; 969 switch (F->getLinkage()) { 970 case GlobalValue::InternalLinkage: Out << "internal "; break; 971 case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 972 case GlobalValue::WeakLinkage: Out << "weak "; break; 973 case GlobalValue::AppendingLinkage: Out << "appending "; break; 974 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 975 case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 976 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 977 case GlobalValue::ExternalLinkage: break; 978 case GlobalValue::GhostLinkage: 979 cerr << "GhostLinkage not allowed in AsmWriter!\n"; 980 abort(); 981 } 982 switch (F->getVisibility()) { 983 default: assert(0 && "Invalid visibility style!"); 984 case GlobalValue::DefaultVisibility: break; 985 case GlobalValue::HiddenVisibility: Out << "hidden "; break; 986 } 987 } 988 989 // Print the calling convention. 990 switch (F->getCallingConv()) { 991 case CallingConv::C: break; // default 992 case CallingConv::CSRet: Out << "csretcc "; break; 993 case CallingConv::Fast: Out << "fastcc "; break; 994 case CallingConv::Cold: Out << "coldcc "; break; 995 case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 996 case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 997 default: Out << "cc" << F->getCallingConv() << " "; break; 998 } 999 1000 const FunctionType *FT = F->getFunctionType(); 1001 printType(F->getReturnType()) << ' '; 1002 if (!F->getName().empty()) 1003 Out << getLLVMName(F->getName()); 1004 else 1005 Out << "\"\""; 1006 Out << '('; 1007 Machine.incorporateFunction(F); 1008 1009 // Loop over the arguments, printing them... 1010 1011 unsigned Idx = 1; 1012 for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); 1013 I != E; ++I) { 1014 // Insert commas as we go... the first arg doesn't get a comma 1015 if (I != F->arg_begin()) Out << ", "; 1016 printArgument(I, FT->getParamAttrs(Idx)); 1017 Idx++; 1018 } 1019 1020 // Finish printing arguments... 1021 if (FT->isVarArg()) { 1022 if (FT->getNumParams()) Out << ", "; 1023 Out << "..."; // Output varargs portion of signature! 1024 } 1025 Out << ')'; 1026 if (FT->getParamAttrs(0)) 1027 Out << ' ' << FunctionType::getParamAttrsText(FT->getParamAttrs(0)); 1028 if (F->hasSection()) 1029 Out << " section \"" << F->getSection() << '"'; 1030 if (F->getAlignment()) 1031 Out << " align " << F->getAlignment(); 1032 1033 if (F->isExternal()) { 1034 Out << "\n"; 1035 } else { 1036 Out << " {"; 1037 1038 // Output all of its basic blocks... for the function 1039 for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 1040 printBasicBlock(I); 1041 1042 Out << "}\n"; 1043 } 1044 1045 Machine.purgeFunction(); 1046} 1047 1048/// printArgument - This member is called for every argument that is passed into 1049/// the function. Simply print it out 1050/// 1051void AssemblyWriter::printArgument(const Argument *Arg, 1052 FunctionType::ParameterAttributes attrs) { 1053 // Output type... 1054 printType(Arg->getType()); 1055 1056 if (attrs != FunctionType::NoAttributeSet) 1057 Out << ' ' << FunctionType::getParamAttrsText(attrs); 1058 1059 // Output name, if available... 1060 if (Arg->hasName()) 1061 Out << ' ' << getLLVMName(Arg->getName()); 1062} 1063 1064/// printBasicBlock - This member is called for each basic block in a method. 1065/// 1066void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 1067 if (BB->hasName()) { // Print out the label if it exists... 1068 Out << "\n" << getLLVMName(BB->getName(), false) << ':'; 1069 } else if (!BB->use_empty()) { // Don't print block # of no uses... 1070 Out << "\n; <label>:"; 1071 int Slot = Machine.getLocalSlot(BB); 1072 if (Slot != -1) 1073 Out << Slot; 1074 else 1075 Out << "<badref>"; 1076 } 1077 1078 if (BB->getParent() == 0) 1079 Out << "\t\t; Error: Block without parent!"; 1080 else { 1081 if (BB != &BB->getParent()->front()) { // Not the entry block? 1082 // Output predecessors for the block... 1083 Out << "\t\t;"; 1084 pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 1085 1086 if (PI == PE) { 1087 Out << " No predecessors!"; 1088 } else { 1089 Out << " preds ="; 1090 writeOperand(*PI, false); 1091 for (++PI; PI != PE; ++PI) { 1092 Out << ','; 1093 writeOperand(*PI, false); 1094 } 1095 } 1096 } 1097 } 1098 1099 Out << "\n"; 1100 1101 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out); 1102 1103 // Output all of the instructions in the basic block... 1104 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1105 printInstruction(*I); 1106 1107 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out); 1108} 1109 1110 1111/// printInfoComment - Print a little comment after the instruction indicating 1112/// which slot it occupies. 1113/// 1114void AssemblyWriter::printInfoComment(const Value &V) { 1115 if (V.getType() != Type::VoidTy) { 1116 Out << "\t\t; <"; 1117 printType(V.getType()) << '>'; 1118 1119 if (!V.hasName()) { 1120 int SlotNum; 1121 if (const GlobalValue *GV = dyn_cast<GlobalValue>(&V)) 1122 SlotNum = Machine.getGlobalSlot(GV); 1123 else 1124 SlotNum = Machine.getLocalSlot(&V); 1125 if (SlotNum == -1) 1126 Out << ":<badref>"; 1127 else 1128 Out << ':' << SlotNum; // Print out the def slot taken. 1129 } 1130 Out << " [#uses=" << V.getNumUses() << ']'; // Output # uses 1131 } 1132} 1133 1134// This member is called for each Instruction in a function.. 1135void AssemblyWriter::printInstruction(const Instruction &I) { 1136 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out); 1137 1138 Out << "\t"; 1139 1140 // Print out name if it exists... 1141 if (I.hasName()) 1142 Out << getLLVMName(I.getName()) << " = "; 1143 1144 // If this is a volatile load or store, print out the volatile marker. 1145 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 1146 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) { 1147 Out << "volatile "; 1148 } else if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) { 1149 // If this is a call, check if it's a tail call. 1150 Out << "tail "; 1151 } 1152 1153 // Print out the opcode... 1154 Out << I.getOpcodeName(); 1155 1156 // Print out the compare instruction predicates 1157 if (const FCmpInst *FCI = dyn_cast<FCmpInst>(&I)) { 1158 Out << " " << getPredicateText(FCI->getPredicate()); 1159 } else if (const ICmpInst *ICI = dyn_cast<ICmpInst>(&I)) { 1160 Out << " " << getPredicateText(ICI->getPredicate()); 1161 } 1162 1163 // Print out the type of the operands... 1164 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 1165 1166 // Special case conditional branches to swizzle the condition out to the front 1167 if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 1168 writeOperand(I.getOperand(2), true); 1169 Out << ','; 1170 writeOperand(Operand, true); 1171 Out << ','; 1172 writeOperand(I.getOperand(1), true); 1173 1174 } else if (isa<SwitchInst>(I)) { 1175 // Special case switch statement to get formatting nice and correct... 1176 writeOperand(Operand , true); Out << ','; 1177 writeOperand(I.getOperand(1), true); Out << " ["; 1178 1179 for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 1180 Out << "\n\t\t"; 1181 writeOperand(I.getOperand(op ), true); Out << ','; 1182 writeOperand(I.getOperand(op+1), true); 1183 } 1184 Out << "\n\t]"; 1185 } else if (isa<PHINode>(I)) { 1186 Out << ' '; 1187 printType(I.getType()); 1188 Out << ' '; 1189 1190 for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 1191 if (op) Out << ", "; 1192 Out << '['; 1193 writeOperand(I.getOperand(op ), false); Out << ','; 1194 writeOperand(I.getOperand(op+1), false); Out << " ]"; 1195 } 1196 } else if (isa<ReturnInst>(I) && !Operand) { 1197 Out << " void"; 1198 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) { 1199 // Print the calling convention being used. 1200 switch (CI->getCallingConv()) { 1201 case CallingConv::C: break; // default 1202 case CallingConv::CSRet: Out << " csretcc"; break; 1203 case CallingConv::Fast: Out << " fastcc"; break; 1204 case CallingConv::Cold: Out << " coldcc"; break; 1205 case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1206 case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1207 default: Out << " cc" << CI->getCallingConv(); break; 1208 } 1209 1210 const PointerType *PTy = cast<PointerType>(Operand->getType()); 1211 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1212 const Type *RetTy = FTy->getReturnType(); 1213 1214 // If possible, print out the short form of the call instruction. We can 1215 // only do this if the first argument is a pointer to a nonvararg function, 1216 // and if the return type is not a pointer to a function. 1217 // 1218 if (!FTy->isVarArg() && 1219 (!isa<PointerType>(RetTy) || 1220 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 1221 Out << ' '; printType(RetTy); 1222 writeOperand(Operand, false); 1223 } else { 1224 writeOperand(Operand, true); 1225 } 1226 Out << '('; 1227 for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) { 1228 if (op > 1) 1229 Out << ','; 1230 writeOperand(I.getOperand(op), true); 1231 if (FTy->getParamAttrs(op) != FunctionType::NoAttributeSet) 1232 Out << " " << FTy->getParamAttrsText(FTy->getParamAttrs(op)); 1233 } 1234 Out << " )"; 1235 if (FTy->getParamAttrs(0) != FunctionType::NoAttributeSet) 1236 Out << ' ' << FTy->getParamAttrsText(FTy->getParamAttrs(0)); 1237 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 1238 const PointerType *PTy = cast<PointerType>(Operand->getType()); 1239 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1240 const Type *RetTy = FTy->getReturnType(); 1241 1242 // Print the calling convention being used. 1243 switch (II->getCallingConv()) { 1244 case CallingConv::C: break; // default 1245 case CallingConv::CSRet: Out << " csretcc"; break; 1246 case CallingConv::Fast: Out << " fastcc"; break; 1247 case CallingConv::Cold: Out << " coldcc"; break; 1248 case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1249 case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1250 default: Out << " cc" << II->getCallingConv(); break; 1251 } 1252 1253 // If possible, print out the short form of the invoke instruction. We can 1254 // only do this if the first argument is a pointer to a nonvararg function, 1255 // and if the return type is not a pointer to a function. 1256 // 1257 if (!FTy->isVarArg() && 1258 (!isa<PointerType>(RetTy) || 1259 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 1260 Out << ' '; printType(RetTy); 1261 writeOperand(Operand, false); 1262 } else { 1263 writeOperand(Operand, true); 1264 } 1265 1266 Out << '('; 1267 for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) { 1268 if (op > 3) 1269 Out << ','; 1270 writeOperand(I.getOperand(op), true); 1271 if (FTy->getParamAttrs(op-2) != FunctionType::NoAttributeSet) 1272 Out << " " << FTy->getParamAttrsText(FTy->getParamAttrs(op-2)); 1273 } 1274 1275 Out << " )"; 1276 if (FTy->getParamAttrs(0) != FunctionType::NoAttributeSet) 1277 Out << " " << FTy->getParamAttrsText(FTy->getParamAttrs(0)); 1278 Out << "\n\t\t\tto"; 1279 writeOperand(II->getNormalDest(), true); 1280 Out << " unwind"; 1281 writeOperand(II->getUnwindDest(), true); 1282 1283 } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 1284 Out << ' '; 1285 printType(AI->getType()->getElementType()); 1286 if (AI->isArrayAllocation()) { 1287 Out << ','; 1288 writeOperand(AI->getArraySize(), true); 1289 } 1290 if (AI->getAlignment()) { 1291 Out << ", align " << AI->getAlignment(); 1292 } 1293 } else if (isa<CastInst>(I)) { 1294 if (Operand) writeOperand(Operand, true); // Work with broken code 1295 Out << " to "; 1296 printType(I.getType()); 1297 } else if (isa<VAArgInst>(I)) { 1298 if (Operand) writeOperand(Operand, true); // Work with broken code 1299 Out << ", "; 1300 printType(I.getType()); 1301 } else if (Operand) { // Print the normal way... 1302 1303 // PrintAllTypes - Instructions who have operands of all the same type 1304 // omit the type from all but the first operand. If the instruction has 1305 // different type operands (for example br), then they are all printed. 1306 bool PrintAllTypes = false; 1307 const Type *TheType = Operand->getType(); 1308 1309 // Shift Left & Right print both types even for Ubyte LHS, and select prints 1310 // types even if all operands are bools. 1311 if (isa<ShiftInst>(I) || isa<SelectInst>(I) || isa<StoreInst>(I) || 1312 isa<ShuffleVectorInst>(I)) { 1313 PrintAllTypes = true; 1314 } else { 1315 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 1316 Operand = I.getOperand(i); 1317 if (Operand->getType() != TheType) { 1318 PrintAllTypes = true; // We have differing types! Print them all! 1319 break; 1320 } 1321 } 1322 } 1323 1324 if (!PrintAllTypes) { 1325 Out << ' '; 1326 printType(TheType); 1327 } 1328 1329 for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 1330 if (i) Out << ','; 1331 writeOperand(I.getOperand(i), PrintAllTypes); 1332 } 1333 } 1334 1335 printInfoComment(I); 1336 Out << "\n"; 1337} 1338 1339 1340//===----------------------------------------------------------------------===// 1341// External Interface declarations 1342//===----------------------------------------------------------------------===// 1343 1344void Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1345 SlotMachine SlotTable(this); 1346 AssemblyWriter W(o, SlotTable, this, AAW); 1347 W.write(this); 1348} 1349 1350void GlobalVariable::print(std::ostream &o) const { 1351 SlotMachine SlotTable(getParent()); 1352 AssemblyWriter W(o, SlotTable, getParent(), 0); 1353 W.write(this); 1354} 1355 1356void Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1357 SlotMachine SlotTable(getParent()); 1358 AssemblyWriter W(o, SlotTable, getParent(), AAW); 1359 1360 W.write(this); 1361} 1362 1363void InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1364 WriteAsOperand(o, this, true, 0); 1365} 1366 1367void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1368 SlotMachine SlotTable(getParent()); 1369 AssemblyWriter W(o, SlotTable, 1370 getParent() ? getParent()->getParent() : 0, AAW); 1371 W.write(this); 1372} 1373 1374void Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1375 const Function *F = getParent() ? getParent()->getParent() : 0; 1376 SlotMachine SlotTable(F); 1377 AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW); 1378 1379 W.write(this); 1380} 1381 1382void Constant::print(std::ostream &o) const { 1383 if (this == 0) { o << "<null> constant value\n"; return; } 1384 1385 o << ' ' << getType()->getDescription() << ' '; 1386 1387 std::map<const Type *, std::string> TypeTable; 1388 WriteConstantInt(o, this, TypeTable, 0); 1389} 1390 1391void Type::print(std::ostream &o) const { 1392 if (this == 0) 1393 o << "<null Type>"; 1394 else 1395 o << getDescription(); 1396} 1397 1398void Argument::print(std::ostream &o) const { 1399 WriteAsOperand(o, this, true, getParent() ? getParent()->getParent() : 0); 1400} 1401 1402// Value::dump - allow easy printing of Values from the debugger. 1403// Located here because so much of the needed functionality is here. 1404void Value::dump() const { print(*cerr.stream()); cerr << '\n'; } 1405 1406// Type::dump - allow easy printing of Values from the debugger. 1407// Located here because so much of the needed functionality is here. 1408void Type::dump() const { print(*cerr.stream()); cerr << '\n'; } 1409 1410//===----------------------------------------------------------------------===// 1411// SlotMachine Implementation 1412//===----------------------------------------------------------------------===// 1413 1414#if 0 1415#define SC_DEBUG(X) cerr << X 1416#else 1417#define SC_DEBUG(X) 1418#endif 1419 1420// Module level constructor. Causes the contents of the Module (sans functions) 1421// to be added to the slot table. 1422SlotMachine::SlotMachine(const Module *M) 1423 : TheModule(M) ///< Saved for lazy initialization. 1424 , TheFunction(0) 1425 , FunctionProcessed(false) 1426{ 1427} 1428 1429// Function level constructor. Causes the contents of the Module and the one 1430// function provided to be added to the slot table. 1431SlotMachine::SlotMachine(const Function *F) 1432 : TheModule(F ? F->getParent() : 0) ///< Saved for lazy initialization 1433 , TheFunction(F) ///< Saved for lazy initialization 1434 , FunctionProcessed(false) 1435{ 1436} 1437 1438inline void SlotMachine::initialize() { 1439 if (TheModule) { 1440 processModule(); 1441 TheModule = 0; ///< Prevent re-processing next time we're called. 1442 } 1443 if (TheFunction && !FunctionProcessed) 1444 processFunction(); 1445} 1446 1447// Iterate through all the global variables, functions, and global 1448// variable initializers and create slots for them. 1449void SlotMachine::processModule() { 1450 SC_DEBUG("begin processModule!\n"); 1451 1452 // Add all of the unnamed global variables to the value table. 1453 for (Module::const_global_iterator I = TheModule->global_begin(), 1454 E = TheModule->global_end(); I != E; ++I) 1455 if (!I->hasName()) 1456 CreateModuleSlot(I); 1457 1458 // Add all the unnamed functions to the table. 1459 for (Module::const_iterator I = TheModule->begin(), E = TheModule->end(); 1460 I != E; ++I) 1461 if (!I->hasName()) 1462 CreateModuleSlot(I); 1463 1464 SC_DEBUG("end processModule!\n"); 1465} 1466 1467 1468// Process the arguments, basic blocks, and instructions of a function. 1469void SlotMachine::processFunction() { 1470 SC_DEBUG("begin processFunction!\n"); 1471 1472 // Add all the function arguments with no names. 1473 for(Function::const_arg_iterator AI = TheFunction->arg_begin(), 1474 AE = TheFunction->arg_end(); AI != AE; ++AI) 1475 if (!AI->hasName()) 1476 CreateFunctionSlot(AI); 1477 1478 SC_DEBUG("Inserting Instructions:\n"); 1479 1480 // Add all of the basic blocks and instructions with no names. 1481 for (Function::const_iterator BB = TheFunction->begin(), 1482 E = TheFunction->end(); BB != E; ++BB) { 1483 if (!BB->hasName()) 1484 CreateFunctionSlot(BB); 1485 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1486 if (I->getType() != Type::VoidTy && !I->hasName()) 1487 CreateFunctionSlot(I); 1488 } 1489 1490 FunctionProcessed = true; 1491 1492 SC_DEBUG("end processFunction!\n"); 1493} 1494 1495/// Clean up after incorporating a function. This is the only way to get out of 1496/// the function incorporation state that affects get*Slot/Create*Slot. Function 1497/// incorporation state is indicated by TheFunction != 0. 1498void SlotMachine::purgeFunction() { 1499 SC_DEBUG("begin purgeFunction!\n"); 1500 fMap.clear(); // Simply discard the function level map 1501 TheFunction = 0; 1502 FunctionProcessed = false; 1503 SC_DEBUG("end purgeFunction!\n"); 1504} 1505 1506/// getGlobalSlot - Get the slot number of a global value. 1507int SlotMachine::getGlobalSlot(const GlobalValue *V) { 1508 // Check for uninitialized state and do lazy initialization. 1509 initialize(); 1510 1511 // Find the type plane in the module map 1512 TypedPlanes::const_iterator MI = mMap.find(V->getType()); 1513 if (MI == mMap.end()) return -1; 1514 1515 // Lookup the value in the module plane's map. 1516 ValueMap::const_iterator MVI = MI->second.map.find(V); 1517 return MVI != MI->second.map.end() ? int(MVI->second) : -1; 1518} 1519 1520 1521/// getLocalSlot - Get the slot number for a value that is local to a function. 1522int SlotMachine::getLocalSlot(const Value *V) { 1523 assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!"); 1524 1525 // Check for uninitialized state and do lazy initialization. 1526 initialize(); 1527 1528 // Get the type of the value 1529 const Type *VTy = V->getType(); 1530 1531 TypedPlanes::const_iterator FI = fMap.find(VTy); 1532 if (FI == fMap.end()) return -1; 1533 1534 // Lookup the Value in the function and module maps. 1535 ValueMap::const_iterator FVI = FI->second.map.find(V); 1536 TypedPlanes::const_iterator MI = mMap.find(VTy); 1537 1538 // If the value doesn't exist in the function map, it is a <badref> 1539 if (FVI == FI->second.map.end()) return -1; 1540 1541 // Return the slot number as the module's contribution to 1542 // the type plane plus the index in the function's contribution 1543 // to the type plane. 1544 if (MI != mMap.end()) 1545 return MI->second.next_slot + FVI->second; 1546 else 1547 return FVI->second; 1548} 1549 1550 1551/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. 1552void SlotMachine::CreateModuleSlot(const GlobalValue *V) { 1553 assert(V && "Can't insert a null Value into SlotMachine!"); 1554 1555 unsigned DestSlot = 0; 1556 const Type *VTy = V->getType(); 1557 1558 ValuePlane &PlaneMap = mMap[VTy]; 1559 DestSlot = PlaneMap.map[V] = PlaneMap.next_slot++; 1560 1561 SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << 1562 DestSlot << " ["); 1563 // G = Global, F = Function, o = other 1564 SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : 'F') << "]\n"); 1565} 1566 1567 1568/// CreateSlot - Create a new slot for the specified value if it has no name. 1569void SlotMachine::CreateFunctionSlot(const Value *V) { 1570 const Type *VTy = V->getType(); 1571 assert(VTy != Type::VoidTy && !V->hasName() && "Doesn't need a slot!"); 1572 1573 unsigned DestSlot = 0; 1574 1575 ValuePlane &PlaneMap = fMap[VTy]; 1576 DestSlot = PlaneMap.map[V] = PlaneMap.next_slot++; 1577 1578 // G = Global, F = Function, o = other 1579 SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << 1580 DestSlot << " [o]\n"); 1581} 1582