lib/VMCore/AsmWriter.cpp

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