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


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

lib/Bytecode/Reader/ConstantReader.cpp

@@ -202,28 +202,8 @@ bool BytecodeParser::parseConstantValue(const uchar *&Buf, const uchar *EndBuf,
                 << 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 @@ bool BytecodeParser::parseConstantValue(const uchar *&Buf, const uchar *EndBuf,
     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 @@ bool BytecodeParser::parseConstantValue(const uchar *&Buf, const uchar *EndBuf,
     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);

lib/Bytecode/Reader/Reader.cpp

@@ -132,6 +132,34 @@ Value *BytecodeParser::getValue(const Type *Ty, unsigned oNum, bool Create) {
   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) {

lib/Bytecode/Reader/ReaderInternals.h

@@ -108,6 +108,7 @@ private:
 
   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);