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.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10837 91177308-0d34-0410-b5e6-96231b3b80d8

6 files changed, 52 insertions, 37 deletions

diff --git a/include/llvm/Analysis/SlotCalculator.h b/include/llvm/Analysis/SlotCalculator.h
index 596f9324ed..60cf516a10 100644
--- a/include/llvm/Analysis/SlotCalculator.h
+++ b/include/llvm/Analysis/SlotCalculator.h
@@ -32,7 +32,12 @@ class SymbolTable;
 
 class SlotCalculator {
   const Module *TheModule;
-  bool IgnoreNamedNodes;     // Shall we not count named nodes?
+
+  // BuildBytecodeInfo - If true, this is the creating information for the
+  // bytecode writer, if false, we are building information for the assembly
+  // emitter.  The assembly emitter doesn't need named objects numbered, among
+  // other differences.
+  bool BuildBytecodeInfo;
 
   typedef std::vector<const Value*> TypePlane;
   std::vector<TypePlane> Table;
@@ -44,9 +49,9 @@ class SlotCalculator {
   std::vector<unsigned> ModuleLevel;
 
 public:
-  SlotCalculator(const Module *M, bool IgnoreNamed);
+  SlotCalculator(const Module *M, bool BuildBytecodeInfo);
   // Start out in incorp state
-  SlotCalculator(const Function *M, bool IgnoreNamed);
+  SlotCalculator(const Function *M, bool BuildBytecodeInfo);
   inline ~SlotCalculator() {}
   
   // getSlot returns < 0 on error!
diff --git a/include/llvm/SlotCalculator.h b/include/llvm/SlotCalculator.h
index 596f9324ed..60cf516a10 100644
--- a/include/llvm/SlotCalculator.h
+++ b/include/llvm/SlotCalculator.h
@@ -32,7 +32,12 @@ class SymbolTable;
 
 class SlotCalculator {
   const Module *TheModule;
-  bool IgnoreNamedNodes;     // Shall we not count named nodes?
+
+  // BuildBytecodeInfo - If true, this is the creating information for the
+  // bytecode writer, if false, we are building information for the assembly
+  // emitter.  The assembly emitter doesn't need named objects numbered, among
+  // other differences.
+  bool BuildBytecodeInfo;
 
   typedef std::vector<const Value*> TypePlane;
   std::vector<TypePlane> Table;
@@ -44,9 +49,9 @@ class SlotCalculator {
   std::vector<unsigned> ModuleLevel;
 
 public:
-  SlotCalculator(const Module *M, bool IgnoreNamed);
+  SlotCalculator(const Module *M, bool BuildBytecodeInfo);
   // Start out in incorp state
-  SlotCalculator(const Function *M, bool IgnoreNamed);
+  SlotCalculator(const Function *M, bool BuildBytecodeInfo);
   inline ~SlotCalculator() {}
   
   // getSlot returns < 0 on error!
diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp
index 5a41b87575..9df4b00074 100644
--- a/lib/Bytecode/Writer/SlotCalculator.cpp
+++ b/lib/Bytecode/Writer/SlotCalculator.cpp
@@ -34,8 +34,8 @@ using namespace llvm;
 #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 @@ SlotCalculator::SlotCalculator(const Module *M, bool IgnoreNamed) {
   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 @@ void SlotCalculator::processModule() {
   // 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 @@ void SlotCalculator::processModule() {
   // 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 @@ void SlotCalculator::processModule() {
   // 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 @@ void SlotCalculator::incorporateFunction(const Function *F) {
   // 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 @@ void SlotCalculator::incorporateFunction(const Function *F) {
         getOrCreateSlot(VAN->getArgType());
     }
 
-  if (!IgnoreNamedNodes) {
+  if (BuildBytecodeInfo) {
     SC_DEBUG("Inserting SymbolTable values:\n");
     processSymbolTable(&F->getSymbolTable());
   }
@@ -327,7 +327,7 @@ int SlotCalculator::insertValue(const Value *D, bool dontIgnore) {
   //
   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 @@ int SlotCalculator::doInsertValue(const Value *D) {
 
   // 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.
diff --git a/lib/Bytecode/Writer/SlotCalculator.h b/lib/Bytecode/Writer/SlotCalculator.h
index 596f9324ed..60cf516a10 100644
--- a/lib/Bytecode/Writer/SlotCalculator.h
+++ b/lib/Bytecode/Writer/SlotCalculator.h
@@ -32,7 +32,12 @@ class SymbolTable;
 
 class SlotCalculator {
   const Module *TheModule;
-  bool IgnoreNamedNodes;     // Shall we not count named nodes?
+
+  // BuildBytecodeInfo - If true, this is the creating information for the
+  // bytecode writer, if false, we are building information for the assembly
+  // emitter.  The assembly emitter doesn't need named objects numbered, among
+  // other differences.
+  bool BuildBytecodeInfo;
 
   typedef std::vector<const Value*> TypePlane;
   std::vector<TypePlane> Table;
@@ -44,9 +49,9 @@ class SlotCalculator {
   std::vector<unsigned> ModuleLevel;
 
 public:
-  SlotCalculator(const Module *M, bool IgnoreNamed);
+  SlotCalculator(const Module *M, bool BuildBytecodeInfo);
   // Start out in incorp state
-  SlotCalculator(const Function *M, bool IgnoreNamed);
+  SlotCalculator(const Function *M, bool BuildBytecodeInfo);
   inline ~SlotCalculator() {}
   
   // getSlot returns < 0 on error!
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 671864972b..98bc093987 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -60,15 +60,15 @@ static const Module *getModuleFromVal(const Value *V) {
 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 Value::dump() const { print(std::cerr); }
 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;
diff --git a/lib/VMCore/SlotCalculator.cpp b/lib/VMCore/SlotCalculator.cpp
index 5a41b87575..9df4b00074 100644
--- a/lib/VMCore/SlotCalculator.cpp
+++ b/lib/VMCore/SlotCalculator.cpp
@@ -34,8 +34,8 @@ using namespace llvm;
 #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 @@ SlotCalculator::SlotCalculator(const Module *M, bool IgnoreNamed) {
   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 @@ void SlotCalculator::processModule() {
   // 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 @@ void SlotCalculator::processModule() {
   // 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 @@ void SlotCalculator::processModule() {
   // 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 @@ void SlotCalculator::incorporateFunction(const Function *F) {
   // 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 @@ void SlotCalculator::incorporateFunction(const Function *F) {
         getOrCreateSlot(VAN->getArgType());
     }
 
-  if (!IgnoreNamedNodes) {
+  if (BuildBytecodeInfo) {
     SC_DEBUG("Inserting SymbolTable values:\n");
     processSymbolTable(&F->getSymbolTable());
   }
@@ -327,7 +327,7 @@ int SlotCalculator::insertValue(const Value *D, bool dontIgnore) {
   //
   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 @@ int SlotCalculator::doInsertValue(const Value *D) {
 
   // 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.