Emit an obnoxious warning message for bytecode that includes load/store

instructions that use indexing.  Convert them transparently into a pair
of instructions.

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

diff --git a/lib/Bytecode/Reader/InstructionReader.cpp b/lib/Bytecode/Reader/InstructionReader.cpp
index 979b3944bc28262d92e7c917e498a8a74094b2b4..1f1485e2f2e56c082627a668b496f9cfc67f2baa 100644 (file)
--- a/lib/Bytecode/Reader/InstructionReader.cpp
+++ b/lib/Bytecode/Reader/InstructionReader.cpp
@@ -116,7 +116,8 @@ bool BytecodeParser::ParseRawInst(const uchar *&Buf, const uchar *EndBuf,
 
 
 bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf,
-                                     Instruction *&Res) {
+                                     Instruction *&Res,
+                                      BasicBlock *BB /*HACK*/) {
   RawInst Raw;
   if (ParseRawInst(Buf, EndBuf, Raw))
     return true;
@@ -388,9 +389,18 @@ bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf,
     }
 
     if (Raw.Opcode == Instruction::Load) {
-      assert(MemAccessInst::getIndexedType(Raw.Ty, Idx) && 
-             "Bad indices for Load!");
-      Res = new LoadInst(getValue(Raw.Ty, Raw.Arg1), Idx);
+      Value *Src = getValue(Raw.Ty, Raw.Arg1);
+      if (!Idx.empty()) {
+        cerr << "WARNING: Bytecode contains load instruction with indices.  "
+             << "Replacing with getelementptr/load pair\n";
+        assert(MemAccessInst::getIndexedType(Raw.Ty, Idx) && 
+               "Bad indices for Load!");
+        Src = new GetElementPtrInst(Src, Idx);
+        // FIXME: Remove this compatibility code and the BB parameter to this
+        // method.
+        BB->getInstList().push_back(cast<Instruction>(Src));
+      }
+      Res = new LoadInst(Src);
     } else if (Raw.Opcode == Instruction::GetElementPtr)
       Res = new GetElementPtrInst(getValue(Raw.Ty, Raw.Arg1), Idx);
     else
@@ -429,10 +439,22 @@ bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf,
       break;
     }
 
-    const Type *ElType = StoreInst::getIndexedType(Raw.Ty, Idx);
-    if (ElType == 0) return true;
-    Res = new StoreInst(getValue(ElType, Raw.Arg1), getValue(Raw.Ty, Raw.Arg2),
-                       Idx);
+    Value *Ptr = getValue(Raw.Ty, Raw.Arg2);
+    if (!Idx.empty()) {
+      cerr << "WARNING: Bytecode contains load instruction with indices.  "
+           << "Replacing with getelementptr/load pair\n";
+
+      const Type *ElType = StoreInst::getIndexedType(Raw.Ty, Idx);
+      if (ElType == 0) return true;
+
+      Ptr = new GetElementPtrInst(Ptr, Idx);
+      // FIXME: Remove this compatibility code and the BB parameter to this
+      // method.
+      BB->getInstList().push_back(cast<Instruction>(Ptr));
+    }
+
+    const Type *ValTy = cast<PointerType>(Ptr->getType())->getElementType();
+    Res = new StoreInst(getValue(ValTy, Raw.Arg1), Ptr);
     return false;
   }
   }  // end switch(Raw.Opcode) 

diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index bbffb1760ee775b6c3851a921e49ec0921cf3be6..dd75d7f26f864c626288ddffec6b7a8d555b5c66 100644 (file)
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -168,7 +168,8 @@ bool BytecodeParser::ParseBasicBlock(const uchar *&Buf, const uchar *EndBuf,
 
   while (Buf < EndBuf) {
     Instruction *Inst;
-    if (ParseInstruction(Buf, EndBuf, Inst)) {
+    if (ParseInstruction(Buf, EndBuf, Inst,
+                         /*HACK*/BB)) {
       delete BB;
       return true;
     }

diff --git a/lib/Bytecode/Reader/ReaderInternals.h b/lib/Bytecode/Reader/ReaderInternals.h
index fdaf13d13c1ff993b568661497675aaac98328f4..c156f515b88ffc2e11a5a2d593fd62255a949117 100644 (file)
--- a/lib/Bytecode/Reader/ReaderInternals.h
+++ b/lib/Bytecode/Reader/ReaderInternals.h
@@ -94,7 +94,8 @@ private:
   bool ParseSymbolTable   (const uchar *&Buf, const uchar *End, SymbolTable *);
   bool ParseMethod        (const uchar *&Buf, const uchar *End, Module *);
   bool ParseBasicBlock    (const uchar *&Buf, const uchar *End, BasicBlock *&);
-  bool ParseInstruction   (const uchar *&Buf, const uchar *End, Instruction *&);
+  bool ParseInstruction   (const uchar *&Buf, const uchar *End, Instruction *&,
+                           BasicBlock *BB /*HACK*/);
   bool ParseRawInst       (const uchar *&Buf, const uchar *End, RawInst &);
 
   bool ParseConstantPool(const uchar *&Buf, const uchar *EndBuf,