when the bitcode reader is referencing a paramattr, make sure to bump its refcount.

[oota-llvm.git] / lib / Bitcode / Reader / BitcodeReader.cpp

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index a82892063b73cb10139ef4348f2818beb87925c7..c86ee3048a9b65cd4df0a4ce4768e77bff6c1301 100644 (file)
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -21,6 +21,7 @@
 #include "llvm/ParamAttrsList.h"
 #include "llvm/AutoUpgrade.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 using namespace llvm;
@@ -30,6 +31,11 @@ void BitcodeReader::FreeState() {
   Buffer = 0;
   std::vector<PATypeHolder>().swap(TypeList);
   ValueList.clear();
+  
+  // Drop references to ParamAttrs.
+  for (unsigned i = 0, e = ParamAttrs.size(); i != e; ++i)
+    ParamAttrs[i]->dropRef();
+  
   std::vector<const ParamAttrsList*>().swap(ParamAttrs);
   std::vector<BasicBlock*>().swap(FunctionBBs);
   std::vector<Function*>().swap(FunctionsWithBodies);
@@ -236,7 +242,13 @@ bool BitcodeReader::ParseParamAttrBlock() {
         if (Record[i+1] != ParamAttr::None)
           Attrs.push_back(ParamAttrsWithIndex::get(Record[i], Record[i+1]));
       }
-      ParamAttrs.push_back(Attrs.empty() ? NULL : ParamAttrsList::get(Attrs));
+      if (Attrs.empty()) {
+        ParamAttrs.push_back(0);
+      } else {
+        ParamAttrs.push_back(ParamAttrsList::get(Attrs));
+        ParamAttrs.back()->addRef();
+      }
+
       Attrs.clear();
       break;
     }
@@ -1075,6 +1087,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
       break;
     }
     // ALIAS: [alias type, aliasee val#, linkage]
+    // ALIAS: [alias type, aliasee val#, linkage, visibility]
     case bitc::MODULE_CODE_ALIAS: {
       if (Record.size() < 3)
         return Error("Invalid MODULE_ALIAS record");
@@ -1084,6 +1097,9 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
       
       GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]),
                                            "", 0, TheModule);
+      // Old bitcode files didn't have visibility field.
+      if (Record.size() > 3)
+        NewGA->setVisibility(GetDecodedVisibility(Record[3]));
       ValueList.push_back(NewGA);
       AliasInits.push_back(std::make_pair(NewGA, Record[1]));
       break;
@@ -1215,6 +1231,15 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       CurBB = FunctionBBs[0];
       continue;
       
+    case bitc::FUNC_CODE_INST_BB_UNWINDDEST:   // BB_UNWINDDEST: [bb#]
+      if (CurBB->getUnwindDest())
+        return Error("Only permit one BB_UNWINDDEST per BB");
+      if (Record.size() != 1)
+        return Error("Invalid BB_UNWINDDEST record");
+
+      CurBB->setUnwindDest(getBasicBlock(Record[0]));
+      continue;
+      
     case bitc::FUNC_CODE_INST_BINOP: {    // BINOP: [opval, ty, opval, opcode]
       unsigned OpNum = 0;
       Value *LHS, *RHS;
@@ -1342,23 +1367,18 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
         if (Size == 0) {
           I = new ReturnInst();
           break;
-        } else if (Size == 1) {
-          unsigned OpNum = 0;
-          Value *Op;
-          if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
-              OpNum != Record.size())
-            return Error("Invalid RET record");
-          I = new ReturnInst(Op);
-          break;
         } else {
-          std::vector<Value *> Vs;
-          Value *Op;
           unsigned OpNum = 0;
-          for (unsigned i = 0; i < Size; ++i) {
-            getValueTypePair(Record, OpNum, NextValueNo, Op);
+          SmallVector<Value *,4> Vs;
+          do {
+            Value *Op = NULL;
+            if (getValueTypePair(Record, OpNum, NextValueNo, Op))
+              return Error("Invalid RET record");
             Vs.push_back(Op);
-          }
-          I = new ReturnInst(Vs);
+          } while(OpNum != Record.size());
+
+          // SmallVector Vs has at least one element.
+          I = new ReturnInst(&Vs[0], Vs.size());
           break;
         }
       }