refactor callers of insertType. inline insertType into its one remaining caller.

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

diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp
index 0ee0389158fceabb1715754d2764b02b00a97051..74af0557ac621cbc8b6ecb6d7e3169b5fe1d8d65 100644 (file)
--- a/lib/Bytecode/Writer/SlotCalculator.cpp
+++ b/lib/Bytecode/Writer/SlotCalculator.cpp
@@ -50,17 +50,17 @@ void SlotCalculator::insertPrimitives() {
   // Reader.h which uses them directly to extract values of these types.
   SC_DEBUG("Inserting primitive types:\n");
                                     // See WellKnownTypeSlots in Reader.h
-  insertType(Type::VoidTy  ); // 0: VoidTySlot
-  insertType(Type::FloatTy ); // 1: FloatTySlot
-  insertType(Type::DoubleTy); // 2: DoubleTySlot
-  insertType(Type::LabelTy ); // 3: LabelTySlot
+  getOrCreateTypeSlot(Type::VoidTy  ); // 0: VoidTySlot
+  getOrCreateTypeSlot(Type::FloatTy ); // 1: FloatTySlot
+  getOrCreateTypeSlot(Type::DoubleTy); // 2: DoubleTySlot
+  getOrCreateTypeSlot(Type::LabelTy ); // 3: LabelTySlot
   assert(TypeMap.size() == Type::FirstDerivedTyID &&"Invalid primitive insert");
   // Above here *must* correspond 1:1 with the primitive types.
-  insertType(Type::Int1Ty  ); // 4: BoolTySlot
-  insertType(Type::Int8Ty  ); // 5: Int8TySlot
-  insertType(Type::Int16Ty ); // 6: Int16TySlot
-  insertType(Type::Int32Ty ); // 7: Int32TySlot
-  insertType(Type::Int64Ty ); // 8: Int64TySlot
+  getOrCreateTypeSlot(Type::Int1Ty  ); // 4: BoolTySlot
+  getOrCreateTypeSlot(Type::Int8Ty  ); // 5: Int8TySlot
+  getOrCreateTypeSlot(Type::Int16Ty ); // 6: Int16TySlot
+  getOrCreateTypeSlot(Type::Int32Ty ); // 7: Int32TySlot
+  getOrCreateTypeSlot(Type::Int64Ty ); // 8: Int64TySlot
 }
 
 SlotCalculator::SlotCalculator(const Module *M) {
@@ -356,15 +356,9 @@ int SlotCalculator::getOrCreateSlot(const Value *V) {
 }
 
 
-unsigned SlotCalculator::getOrCreateTypeSlot(const Type* T) {
-  int SlotNo = getTypeSlot(T);        // Check to see if it's already in!
+unsigned SlotCalculator::getOrCreateTypeSlot(const Type *Ty) {
+  int SlotNo = getTypeSlot(Ty);        // Check to see if it's already in!
   if (SlotNo != -1) return (unsigned)SlotNo;
-  return insertType(T);
-}
-
-unsigned SlotCalculator::insertType(const Type *Ty) {
-  assert(Ty && "Can't insert a null type!");
-  assert(getTypeSlot(Ty) == -1 && "Type is already in the table!");
 
   // Insert the current type before any subtypes.  This is important because
   // recursive types elements are inserted in a bottom up order.  Changing

diff --git a/lib/Bytecode/Writer/SlotCalculator.h b/lib/Bytecode/Writer/SlotCalculator.h
index a57b202a8ad79a95d630b77c2d8c60548d15f0af..5fc15baacef7736dbd87aa6a260a7af8ce8b8941 100644 (file)
--- a/lib/Bytecode/Writer/SlotCalculator.h
+++ b/lib/Bytecode/Writer/SlotCalculator.h
@@ -111,12 +111,6 @@ private:
   int getOrCreateSlot(const Value *V);
   unsigned getOrCreateTypeSlot(const Type *T);
 
-  // insertValue - Insert a value into the value table... Return the
-  // slot that it occupies, or -1 if the declaration is to be ignored
-  // because of the IgnoreNamedNodes flag.
-  //
-  unsigned insertType(const Type *T);
-
   // doInsertValue - Small helper function to be called only be insertVal.
   unsigned doInsertType(const Type *T);