From 162b02e327873f2460dc9f2863f7ef7e77df9d56 Mon Sep 17 00:00:00 2001
From: Reid Spencer <rspencer@reidspencer.com>
Date: Wed, 10 Jan 2007 09:18:16 +0000
Subject: [PATCH] Back out the last patch which is a nightly test killer. The
 assertion in getLocalSlot fires on many, many values. It broke nearly all of
 the dejagnu tests. Simple changes to the assertion did not fix the problem.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33054 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/VMCore/AsmWriter.cpp | 126 +++++++++++++++++++--------------------
 1 file changed, 63 insertions(+), 63 deletions(-)

diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 80b54c58d92..263385c6119 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -75,9 +75,9 @@ public:
 /// @{
 public:
   /// Return the slot number of the specified value in it's type
-  /// plane.  If something is not in the SlotMachine, return -1.
-  int getLocalSlot(const Value *V);
-  int getGlobalSlot(const GlobalValue *V);
+  /// plane.  Its an error to ask for something not in the SlotMachine.
+  /// Its an error to ask for a Type*
+  int getSlot(const Value *V);
 
 /// @}
 /// @name Mutators
@@ -597,20 +597,13 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
     } else {
       int Slot;
       if (Machine) {
-        if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
-          Slot = Machine->getGlobalSlot(GV);
-        else
-          Slot = Machine->getLocalSlot(V);
+        Slot = Machine->getSlot(V);
       } else {
         Machine = createSlotMachine(V);
-        if (Machine) {
-          if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
-            Slot = Machine->getGlobalSlot(GV);
-          else
-            Slot = Machine->getLocalSlot(V);
-        } else {
+        if (Machine)
+          Slot = Machine->getSlot(V);
+        else
           Slot = -1;
-        }
         delete Machine;
       }
       if (Slot != -1)
@@ -1049,7 +1042,7 @@ void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
     Out << "\n" << getLLVMName(BB->getName(), false) << ':';
   } else if (!BB->use_empty()) {      // Don't print block # of no uses...
     Out << "\n; <label>:";
-    int Slot = Machine.getLocalSlot(BB);
+    int Slot = Machine.getSlot(BB);
     if (Slot != -1)
       Out << Slot;
     else
@@ -1098,7 +1091,7 @@ void AssemblyWriter::printInfoComment(const Value &V) {
     printType(V.getType()) << '>';
 
     if (!V.hasName()) {
-      int SlotNum = Machine.getLocalSlot(&V);
+      int SlotNum = Machine.getSlot(&V);
       if (SlotNum == -1)
         Out << ":<badref>";
       else
@@ -1412,7 +1405,7 @@ SlotMachine::SlotMachine(const Function *F)
 {
 }
 
-inline void SlotMachine::initialize() {
+inline void SlotMachine::initialize(void) {
   if (TheModule) {
     processModule();
     TheModule = 0; ///< Prevent re-processing next time we're called.
@@ -1470,7 +1463,7 @@ void SlotMachine::processFunction() {
 }
 
 /// Clean up after incorporating a function. This is the only way to get out of
-/// the function incorporation state that affects get*Slot/Create*Slot. Function
+/// the function incorporation state that affects getSlot/Create*Slot. Function
 /// incorporation state is indicated by TheFunction != 0.
 void SlotMachine::purgeFunction() {
   SC_DEBUG("begin purgeFunction!\n");
@@ -1480,57 +1473,64 @@ void SlotMachine::purgeFunction() {
   SC_DEBUG("end purgeFunction!\n");
 }
 
-/// getGlobalSlot - Get the slot number of a global value.
-int SlotMachine::getGlobalSlot(const GlobalValue *V) {
-  // Check for uninitialized state and do lazy initialization.
-  initialize();
-  
-  // Find the type plane in the module map
-  TypedPlanes::const_iterator MI = mMap.find(V->getType());
-  if (MI == mMap.end()) return -1;
-  
-  // Lookup the value in the module plane's map.
-  ValueMap::const_iterator MVI = MI->second.map.find(V);
-  return MVI != MI->second.map.end() ? MVI->second : -1;
-}
+/// Get the slot number for a value. This function will assert if you
+/// ask for a Value that hasn't previously been inserted with Create*Slot.
+int SlotMachine::getSlot(const Value *V) {
+  assert(V && "Can't get slot for null Value");
+  assert(!isa<Constant>(V) || isa<GlobalValue>(V) &&
+    "Can't insert a non-GlobalValue Constant into SlotMachine");
 
-
-/// getLocalSlot - Get the slot number for a value that is local to a function.
-int SlotMachine::getLocalSlot(const Value *V) {
-  assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");
-
-  // Check for uninitialized state and do lazy initialization.
-  initialize();
+  // Check for uninitialized state and do lazy initialization
+  this->initialize();
 
   // Get the type of the value
-  const Type *VTy = V->getType();
+  const Type* VTy = V->getType();
 
-  TypedPlanes::const_iterator FI = fMap.find(VTy);
-  if (FI == fMap.end()) return -1;
-  
-  // Lookup the Value in the function and module maps.
-  ValueMap::const_iterator FVI = FI->second.map.find(V);
+  // Find the type plane in the module map
   TypedPlanes::const_iterator MI = mMap.find(VTy);
-  
-  // If the value doesn't exist in the function map
-  if (FVI == FI->second.map.end()) {
-    // Look up the value in the module map.
-    if (MI == mMap.end()) return -1;
-    ValueMap::const_iterator MVI = MI->second.map.find(V);
-    // If we didn't find it, it wasn't inserted
-    if (MVI == MI->second.map.end()) return -1;
-    assert(MVI != MI->second.map.end() && "Value not found");
-    // We found it only at the module level
-    return MVI->second;
+
+  if (TheFunction) {
+    // Lookup the type in the function map too
+    TypedPlanes::const_iterator FI = fMap.find(VTy);
+    // If there is a corresponding type plane in the function map
+    if (FI != fMap.end()) {
+      // Lookup the Value in the function map
+      ValueMap::const_iterator FVI = FI->second.map.find(V);
+      // If the value doesn't exist in the function map
+      if (FVI == FI->second.map.end()) {
+        // Look up the value in the module map.
+        if (MI == mMap.end()) return -1;
+        ValueMap::const_iterator MVI = MI->second.map.find(V);
+        // If we didn't find it, it wasn't inserted
+        if (MVI == MI->second.map.end()) return -1;
+        assert(MVI != MI->second.map.end() && "Value not found");
+        // We found it only at the module level
+        return MVI->second;
+
+      // else the value exists in the function map
+      } else {
+        // Return the slot number as the module's contribution to
+        // the type plane plus the index in the function's contribution
+        // to the type plane.
+        if (MI != mMap.end())
+          return MI->second.next_slot + FVI->second;
+        else
+          return FVI->second;
+      }
+    }
   }
-  
-  // Return the slot number as the module's contribution to
-  // the type plane plus the index in the function's contribution
-  // to the type plane.
-  if (MI != mMap.end())
-    return MI->second.next_slot + FVI->second;
-  else
-    return FVI->second;
+
+  // N.B. Can get here only if either !TheFunction or the function doesn't
+  // have a corresponding type plane for the Value
+
+  // Make sure the type plane exists
+  if (MI == mMap.end()) return -1;
+  // Lookup the value in the module's map
+  ValueMap::const_iterator MVI = MI->second.map.find(V);
+  // Make sure we found it.
+  if (MVI == MI->second.map.end()) return -1;
+  // Return it.
+  return MVI->second;
 }