[llvm-commits] CVS: llvm/lib/VMCore/AsmWriter.cpp SlotCalculator.cpp

[Chris Lattner]

Changes in directory llvm/lib/VMCore:

AsmWriter.cpp updated: 1.113 -> 1.114
SlotCalculator.cpp updated: 1.42 -> 1.43

---
Log message:

The only clients of the slot calculator are now the asmwriter and bcwriter.
Since this really only makes sense for these two, change hte instance variable
to reflect whether we are writing a bytecode file or not.  This makes it 
reasonable to add bcwriter specific stuff to it as necessary.


---
Diffs of the changes:  (+17 -17)

Index: llvm/lib/VMCore/AsmWriter.cpp
diff -u llvm/lib/VMCore/AsmWriter.cpp:1.113 llvm/lib/VMCore/AsmWriter.cpp:1.114
--- llvm/lib/VMCore/AsmWriter.cpp:1.113	Fri Nov 21 14:23:48 2003
+++ llvm/lib/VMCore/AsmWriter.cpp	Tue Jan 13 20:49:34 2004
@@ -60,15 +60,15 @@
 static SlotCalculator *createSlotCalculator(const Value *V) {
   assert(!isa<Type>(V) && "Can't create an SC for a type!");
   if (const Argument *FA = dyn_cast<Argument>(V)) {
-    return new SlotCalculator(FA->getParent(), true);
+    return new SlotCalculator(FA->getParent(), false);
   } else if (const Instruction *I = dyn_cast<Instruction>(V)) {
-    return new SlotCalculator(I->getParent()->getParent(), true);
+    return new SlotCalculator(I->getParent()->getParent(), false);
   } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
-    return new SlotCalculator(BB->getParent(), true);
+    return new SlotCalculator(BB->getParent(), false);
   } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){
-    return new SlotCalculator(GV->getParent(), true);
+    return new SlotCalculator(GV->getParent(), false);
   } else if (const Function *Func = dyn_cast<Function>(V)) {
-    return new SlotCalculator(Func, true);
+    return new SlotCalculator(Func, false);
   }
   return 0;
 }
@@ -1037,7 +1037,7 @@
 void CachedWriter::setModule(const Module *M) {
   delete SC; delete AW;
   if (M) {
-    SC = new SlotCalculator(M, true);
+    SC = new SlotCalculator(M, false);
     AW = new AssemblyWriter(Out, *SC, M, 0);
   } else {
     SC = 0; AW = 0;


Index: llvm/lib/VMCore/SlotCalculator.cpp
diff -u llvm/lib/VMCore/SlotCalculator.cpp:1.42 llvm/lib/VMCore/SlotCalculator.cpp:1.43
--- llvm/lib/VMCore/SlotCalculator.cpp:1.42	Sun Jan 11 17:30:03 2004
+++ llvm/lib/VMCore/SlotCalculator.cpp	Tue Jan 13 20:49:34 2004
@@ -34,8 +34,8 @@
 #define SC_DEBUG(X)
 #endif
 
-SlotCalculator::SlotCalculator(const Module *M, bool IgnoreNamed) {
-  IgnoreNamedNodes = IgnoreNamed;
+SlotCalculator::SlotCalculator(const Module *M, bool buildBytecodeInfo) {
+  BuildBytecodeInfo = buildBytecodeInfo;
   TheModule = M;
 
   // Preload table... Make sure that all of the primitive types are in the table
@@ -51,8 +51,8 @@
   processModule();
 }
 
-SlotCalculator::SlotCalculator(const Function *M, bool IgnoreNamed) {
-  IgnoreNamedNodes = IgnoreNamed;
+SlotCalculator::SlotCalculator(const Function *M, bool buildBytecodeInfo) {
+  BuildBytecodeInfo = buildBytecodeInfo;
   TheModule = M ? M->getParent() : 0;
 
   // Preload table... Make sure that all of the primitive types are in the table
@@ -106,7 +106,7 @@
   // constants, which allows us to emit more compact modules.  This is optional,
   // and is just used to compactify the constants used by different functions
   // together.
-  if (!IgnoreNamedNodes) {
+  if (BuildBytecodeInfo) {
     SC_DEBUG("Inserting function constants:\n");
     for (Module::const_iterator F = TheModule->begin(), E = TheModule->end();
          F != E; ++F)
@@ -118,7 +118,7 @@
   // Insert constants that are named at module level into the slot pool so that
   // the module symbol table can refer to them...
   //
-  if (!IgnoreNamedNodes) {
+  if (BuildBytecodeInfo) {
     SC_DEBUG("Inserting SymbolTable values:\n");
     processSymbolTable(&TheModule->getSymbolTable());
   }
@@ -132,7 +132,7 @@
   // all non-value types are pushed to the end of the type table, giving nice
   // low numbers to the types that can be used by instructions, thus reducing
   // the amount of explodage we suffer.
-  if (!IgnoreNamedNodes && Table[Type::TypeTyID].size() >= 64) {
+  if (BuildBytecodeInfo && Table[Type::TypeTyID].size() >= 64) {
     // Scan through the type table moving value types to the start of the table.
     TypePlane *Types = &Table[Type::TypeTyID];
     unsigned FirstNonValueTypeID = 0;
@@ -205,7 +205,7 @@
   // nonconstant values.  This will be turned into the constant pool for the
   // bytecode writer.
   //
-  if (!IgnoreNamedNodes) {                // Assembly writer does not need this!
+  if (BuildBytecodeInfo) {                // Assembly writer does not need this!
     SC_DEBUG("Inserting function constants:\n";
 	     for (constant_iterator I = constant_begin(F), E = constant_end(F);
 		  I != E; ++I) {
@@ -242,7 +242,7 @@
         getOrCreateSlot(VAN->getArgType());
     }
 
-  if (!IgnoreNamedNodes) {
+  if (BuildBytecodeInfo) {
     SC_DEBUG("Inserting SymbolTable values:\n");
     processSymbolTable(&F->getSymbolTable());
   }
@@ -327,7 +327,7 @@
   //
   if (!dontIgnore)                               // Don't ignore nonignorables!
     if (D->getType() == Type::VoidTy ||          // Ignore void type nodes
-	(IgnoreNamedNodes &&                     // Ignore named and constants
+	(!BuildBytecodeInfo &&                   // Ignore named and constants
 	 (D->hasName() || isa<Constant>(D)) && !isa<Type>(D))) {
       SC_DEBUG("ignored value " << *D << "\n");
       return -1;                  // We do need types unconditionally though
@@ -398,7 +398,7 @@
 
   // If this is the first value to get inserted into the type plane, make sure
   // to insert the implicit null value...
-  if (Table[Ty].empty() && Ty >= Type::FirstDerivedTyID && !IgnoreNamedNodes) {
+  if (Table[Ty].empty() && Ty >= Type::FirstDerivedTyID && BuildBytecodeInfo) {
     Value *ZeroInitializer = Constant::getNullValue(Typ);
 
     // If we are pushing zeroinit, it will be handled below.