[llvm-commits] CVS: llvm/lib/Bytecode/Reader/ReadConst.cpp Reader.cpp ReaderInternals.h

[Chris Lattner]

Changes in directory llvm/lib/Bytecode/Reader:

ReadConst.cpp updated: 1.39 -> 1.40
Reader.cpp updated: 1.37 -> 1.38
ReaderInternals.h updated: 1.28 -> 1.29

---
Log message:

There is no way to guarantee that constants are not forward referenced.
Handle forward referenced constants in a general way.  This fixes bug:
Assembler/2002-10-13-ConstantEncodingProblem.llx and allows the SPEC
197.parser benchmark to be built



---
Diffs of the changes:

Index: llvm/lib/Bytecode/Reader/ReadConst.cpp
diff -u llvm/lib/Bytecode/Reader/ReadConst.cpp:1.39 llvm/lib/Bytecode/Reader/ReadConst.cpp:1.40
--- llvm/lib/Bytecode/Reader/ReadConst.cpp:1.39	Mon Aug 19 11:48:21 2002
+++ llvm/lib/Bytecode/Reader/ReadConst.cpp	Sun Oct 13 22:33:02 2002
@@ -202,28 +202,8 @@
                 << ArgValSlot << "\n");
       
       // Get the arg value from its slot if it exists, otherwise a placeholder
-      Value *Val = getValue(ArgTy, ArgValSlot, false);
-      Constant *C;
-      if (Val) {
-        if (!(C = dyn_cast<Constant>(Val))) return true;
-        BCR_TRACE(5, "Constant Found in ValueTable!\n");
-      } else {         // Nope... find or create a forward ref. for it
-        GlobalRefsType::iterator I =
-          GlobalRefs.find(make_pair(ArgTy, ArgValSlot));
-  
-        if (I != GlobalRefs.end()) {
-          BCR_TRACE(5, "Previous forward ref found!\n");
-          C = cast<Constant>(I->second);
-        } else {
-          // Create a placeholder for the constant reference and
-          // keep track of the fact that we have a forward ref to recycle it
-          BCR_TRACE(5, "Creating new forward ref to a constant!\n");
-          C = new ConstPHolder(ArgTy, ArgValSlot);
-
-          // Keep track of the fact that we have a forward ref to recycle it
-          GlobalRefs.insert(make_pair(make_pair(ArgTy, ArgValSlot), C));
-        }
-      }
+      Constant *C = getConstantValue(ArgTy, ArgValSlot);
+      if (C == 0) return true;
       ArgVec.push_back(C);
     }
     
@@ -310,9 +290,9 @@
     while (NumElements--) {   // Read all of the elements of the constant.
       unsigned Slot;
       if (read_vbr(Buf, EndBuf, Slot)) return true;
-      Value *V = getValue(AT->getElementType(), Slot, false);
-      if (!V || !isa<Constant>(V)) return true;
-      Elements.push_back(cast<Constant>(V));
+      Constant *C = getConstantValue(AT->getElementType(), Slot);
+      if (!C) return true;
+      Elements.push_back(C);
     }
     V = ConstantArray::get(AT, Elements);
     break;
@@ -326,10 +306,9 @@
     for (unsigned i = 0; i < ET.size(); ++i) {
       unsigned Slot;
       if (read_vbr(Buf, EndBuf, Slot)) return true;
-      Value *V = getValue(ET[i], Slot, false);
-      if (!V || !isa<Constant>(V))
-	return true;
-      Elements.push_back(cast<Constant>(V));      
+      Constant *C = getConstantValue(ET[i], Slot);
+      if (!C) return true;
+      Elements.push_back(C);
     }
 
     V = ConstantStruct::get(ST, Elements);


Index: llvm/lib/Bytecode/Reader/Reader.cpp
diff -u llvm/lib/Bytecode/Reader/Reader.cpp:1.37 llvm/lib/Bytecode/Reader/Reader.cpp:1.38
--- llvm/lib/Bytecode/Reader/Reader.cpp:1.37	Sun Oct 13 15:53:09 2002
+++ llvm/lib/Bytecode/Reader/Reader.cpp	Sun Oct 13 22:33:02 2002
@@ -132,6 +132,34 @@
   return d;
 }
 
+/// getConstantValue - Just like getValue, except that it returns a null pointer
+/// only on error.  It always returns a constant (meaning that if the value is
+/// defined, but is not a constant, that is an error).  If the specified
+/// constant hasn't been parsed yet, a placeholder is defined and used.  Later,
+/// after the real value is parsed, the placeholder is eliminated.
+///
+Constant *BytecodeParser::getConstantValue(const Type *Ty, unsigned Slot) {
+  if (Value *V = getValue(Ty, Slot, false))
+    return dyn_cast<Constant>(V);      // If we already have the value parsed...
+
+  GlobalRefsType::iterator I = GlobalRefs.find(make_pair(Ty, Slot));
+  if (I != GlobalRefs.end()) {
+    BCR_TRACE(5, "Previous forward ref found!\n");
+    return cast<Constant>(I->second);
+  } else {
+    // Create a placeholder for the constant reference and
+    // keep track of the fact that we have a forward ref to recycle it
+    BCR_TRACE(5, "Creating new forward ref to a constant!\n");
+    Constant *C = new ConstPHolder(Ty, Slot);
+    
+    // Keep track of the fact that we have a forward ref to recycle it
+    GlobalRefs.insert(make_pair(make_pair(Ty, Slot), C));
+    return C;
+  }
+}
+
+
+
 bool BytecodeParser::postResolveValues(ValueTable &ValTab) {
   bool Error = false;
   for (unsigned ty = 0; ty < ValTab.size(); ++ty) {


Index: llvm/lib/Bytecode/Reader/ReaderInternals.h
diff -u llvm/lib/Bytecode/Reader/ReaderInternals.h:1.28 llvm/lib/Bytecode/Reader/ReaderInternals.h:1.29
--- llvm/lib/Bytecode/Reader/ReaderInternals.h:1.28	Wed Aug 21 17:55:27 2002
+++ llvm/lib/Bytecode/Reader/ReaderInternals.h	Sun Oct 13 22:33:02 2002
@@ -108,6 +108,7 @@
 
   Value      *getValue(const Type *Ty, unsigned num, bool Create = true);
   const Type *getType(unsigned ID);
+  Constant   *getConstantValue(const Type *Ty, unsigned num);
 
   int insertValue(Value *D, std::vector<ValueList> &D);  // -1 = Failure
   bool postResolveValues(ValueTable &ValTab);