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