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