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 72756ef6cd6f5e1d9beb2d61ec6eb27a6dbea094..c86ee3048a9b65cd4df0a4ce4768e77bff6c1301 100644 (file)
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License.  See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -18,9 +18,10 @@
 #include "llvm/InlineAsm.h"
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
-#include "llvm/ParameterAttributes.h"
+#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;
     }
@@ -873,7 +885,8 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
       // Look for intrinsic functions which need to be upgraded at some point
       for (Module::iterator FI = TheModule->begin(), FE = TheModule->end();
            FI != FE; ++FI) {
-        if (Function* NewFn = UpgradeIntrinsicFunction(FI))
+        Function* NewFn;
+        if (UpgradeIntrinsicFunction(FI, NewFn))
           UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn));
       }
 
@@ -1074,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");
@@ -1083,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;
@@ -1214,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;
@@ -1324,19 +1350,37 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
         I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
       break;
     }
+    case bitc::FUNC_CODE_INST_GETRESULT: { // GETRESULT: [ty, val, n]
+      if (Record.size() != 2)
+        return Error("Invalid GETRESULT record");
+      unsigned OpNum = 0;
+      Value *Op;
+      getValueTypePair(Record, OpNum, NextValueNo, Op);
+      unsigned Index = Record[1];
+      I = new GetResultInst(Op, Index);
+      break;
+    }
     
     case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
-      if (Record.size() == 0) {
-        I = new ReturnInst();
-        break;
-      } else {
-        unsigned OpNum = 0;
-        Value *Op;
-        if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
-            OpNum != Record.size())
-          return Error("Invalid RET record");
-        I = new ReturnInst(Op);
-        break;
+      {
+        unsigned Size = Record.size();
+        if (Size == 0) {
+          I = new ReturnInst();
+          break;
+        } else {
+          unsigned OpNum = 0;
+          SmallVector<Value *,4> Vs;
+          do {
+            Value *Op = NULL;
+            if (getValueTypePair(Record, OpNum, NextValueNo, Op))
+              return Error("Invalid RET record");
+            Vs.push_back(Op);
+          } while(OpNum != Record.size());
+
+          // SmallVector Vs has at least one element.
+          I = new ReturnInst(&Vs[0], Vs.size());
+          break;
+        }
       }
     case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
       if (Record.size() != 1 && Record.size() != 3)
@@ -1509,7 +1553,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       unsigned OpNum = 0;
       Value *Val, *Ptr;
       if (getValueTypePair(Record, OpNum, NextValueNo, Val) ||
-          getValue(Record, OpNum, PointerType::get(Val->getType()), Ptr) ||
+          getValue(Record, OpNum, PointerType::getUnqual(Val->getType()), Ptr)||
           OpNum+2 != Record.size())
         return Error("Invalid STORE record");