diff options
| author | Stephen Hines <srhines@google.com> | 2014-12-01 14:51:49 -0800 |
|---|---|---|
| committer | Stephen Hines <srhines@google.com> | 2014-12-02 16:08:10 -0800 |
| commit | 37ed9c199ca639565f6ce88105f9e39e898d82d0 (patch) | |
| tree | 8fb36d3910e3ee4c4e1b7422f4f017108efc52f5 /lib/Bitcode/Reader/BitcodeReader.cpp | |
| parent | d2327b22152ced7bc46dc629fc908959e8a52d03 (diff) | |
| download | external_llvm-37ed9c199ca639565f6ce88105f9e39e898d82d0.zip external_llvm-37ed9c199ca639565f6ce88105f9e39e898d82d0.tar.gz external_llvm-37ed9c199ca639565f6ce88105f9e39e898d82d0.tar.bz2 | |
Update aosp/master LLVM for rebase to r222494.
Change-Id: Ic787f5e0124df789bd26f3f24680f45e678eef2d
Diffstat (limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')
| -rw-r--r-- | lib/Bitcode/Reader/BitcodeReader.cpp | 779 |
1 files changed, 446 insertions, 333 deletions
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 192f753..b2ca22c 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -25,17 +25,45 @@ #include "llvm/Support/MathExtras.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/raw_ostream.h" +#include "llvm/Support/ManagedStatic.h" + using namespace llvm; enum { SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex }; -void BitcodeReader::materializeForwardReferencedFunctions() { - while (!BlockAddrFwdRefs.empty()) { - Function *F = BlockAddrFwdRefs.begin()->first; - F->Materialize(); +std::error_code BitcodeReader::materializeForwardReferencedFunctions() { + if (WillMaterializeAllForwardRefs) + return std::error_code(); + + // Prevent recursion. + WillMaterializeAllForwardRefs = true; + + while (!BasicBlockFwdRefQueue.empty()) { + Function *F = BasicBlockFwdRefQueue.front(); + BasicBlockFwdRefQueue.pop_front(); + assert(F && "Expected valid function"); + if (!BasicBlockFwdRefs.count(F)) + // Already materialized. + continue; + + // Check for a function that isn't materializable to prevent an infinite + // loop. When parsing a blockaddress stored in a global variable, there + // isn't a trivial way to check if a function will have a body without a + // linear search through FunctionsWithBodies, so just check it here. + if (!F->isMaterializable()) + return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress); + + // Try to materialize F. + if (std::error_code EC = materialize(F)) + return EC; } + assert(BasicBlockFwdRefs.empty() && "Function missing from queue"); + + // Reset state. + WillMaterializeAllForwardRefs = false; + return std::error_code(); } void BitcodeReader::FreeState() { @@ -51,7 +79,8 @@ void BitcodeReader::FreeState() { DeferredFunctionInfo.clear(); MDKindMap.clear(); - assert(BlockAddrFwdRefs.empty() && "Unresolved blockaddress fwd references"); + assert(BasicBlockFwdRefs.empty() && "Unresolved blockaddress fwd references"); + BasicBlockFwdRefQueue.clear(); } //===----------------------------------------------------------------------===// @@ -487,10 +516,10 @@ static void decodeLLVMAttributesForBitcode(AttrBuilder &B, std::error_code BitcodeReader::ParseAttributeBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (!MAttributes.empty()) - return Error(InvalidMultipleBlocks); + return Error(BitcodeError::InvalidMultipleBlocks); SmallVector<uint64_t, 64> Record; @@ -503,7 +532,7 @@ std::error_code BitcodeReader::ParseAttributeBlock() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -519,7 +548,7 @@ std::error_code BitcodeReader::ParseAttributeBlock() { case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] // FIXME: Remove in 4.0. if (Record.size() & 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); for (unsigned i = 0, e = Record.size(); i != e; i += 2) { AttrBuilder B; @@ -588,6 +617,8 @@ static Attribute::AttrKind GetAttrFromCode(uint64_t Code) { return Attribute::NonLazyBind; case bitc::ATTR_KIND_NON_NULL: return Attribute::NonNull; + case bitc::ATTR_KIND_DEREFERENCEABLE: + return Attribute::Dereferenceable; case bitc::ATTR_KIND_NO_RED_ZONE: return Attribute::NoRedZone; case bitc::ATTR_KIND_NO_RETURN: @@ -635,16 +666,16 @@ std::error_code BitcodeReader::ParseAttrKind(uint64_t Code, Attribute::AttrKind *Kind) { *Kind = GetAttrFromCode(Code); if (*Kind == Attribute::None) - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); return std::error_code(); } std::error_code BitcodeReader::ParseAttributeGroupBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (!MAttributeGroups.empty()) - return Error(InvalidMultipleBlocks); + return Error(BitcodeError::InvalidMultipleBlocks); SmallVector<uint64_t, 64> Record; @@ -655,7 +686,7 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -670,7 +701,7 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { break; case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); uint64_t GrpID = Record[0]; uint64_t Idx = Record[1]; // Index of the object this attribute refers to. @@ -683,14 +714,16 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { return EC; B.addAttribute(Kind); - } else if (Record[i] == 1) { // Align attribute + } else if (Record[i] == 1) { // Integer attribute Attribute::AttrKind Kind; if (std::error_code EC = ParseAttrKind(Record[++i], &Kind)) return EC; if (Kind == Attribute::Alignment) B.addAlignmentAttr(Record[++i]); - else + else if (Kind == Attribute::StackAlignment) B.addStackAlignmentAttr(Record[++i]); + else if (Kind == Attribute::Dereferenceable) + B.addDereferenceableAttr(Record[++i]); } else { // String attribute assert((Record[i] == 3 || Record[i] == 4) && "Invalid attribute group entry"); @@ -723,14 +756,14 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { std::error_code BitcodeReader::ParseTypeTable() { if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); return ParseTypeTableBody(); } std::error_code BitcodeReader::ParseTypeTableBody() { if (!TypeList.empty()) - return Error(InvalidMultipleBlocks); + return Error(BitcodeError::InvalidMultipleBlocks); SmallVector<uint64_t, 64> Record; unsigned NumRecords = 0; @@ -744,10 +777,10 @@ std::error_code BitcodeReader::ParseTypeTableBody() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: if (NumRecords != TypeList.size()) - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); return std::error_code(); case BitstreamEntry::Record: // The interesting case. @@ -759,12 +792,12 @@ std::error_code BitcodeReader::ParseTypeTableBody() { Type *ResultTy = nullptr; switch (Stream.readRecord(Entry.ID, Record)) { default: - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] // TYPE_CODE_NUMENTRY contains a count of the number of types in the // type list. This allows us to reserve space. if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); TypeList.resize(Record[0]); continue; case bitc::TYPE_CODE_VOID: // VOID @@ -799,20 +832,20 @@ std::error_code BitcodeReader::ParseTypeTableBody() { break; case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); ResultTy = IntegerType::get(Context, Record[0]); break; case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or // [pointee type, address space] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned AddressSpace = 0; if (Record.size() == 2) AddressSpace = Record[1]; ResultTy = getTypeByID(Record[0]); if (!ResultTy) - return Error(InvalidType); + return Error(BitcodeError::InvalidType); ResultTy = PointerType::get(ResultTy, AddressSpace); break; } @@ -820,7 +853,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { // FIXME: attrid is dead, remove it in LLVM 4.0 // FUNCTION: [vararg, attrid, retty, paramty x N] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Type*, 8> ArgTys; for (unsigned i = 3, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -831,7 +864,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { ResultTy = getTypeByID(Record[2]); if (!ResultTy || ArgTys.size() < Record.size()-3) - return Error(InvalidType); + return Error(BitcodeError::InvalidType); ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); break; @@ -839,7 +872,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { case bitc::TYPE_CODE_FUNCTION: { // FUNCTION: [vararg, retty, paramty x N] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Type*, 8> ArgTys; for (unsigned i = 2, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -850,14 +883,14 @@ std::error_code BitcodeReader::ParseTypeTableBody() { ResultTy = getTypeByID(Record[1]); if (!ResultTy || ArgTys.size() < Record.size()-2) - return Error(InvalidType); + return Error(BitcodeError::InvalidType); ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); break; } case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Type*, 8> EltTys; for (unsigned i = 1, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -866,21 +899,21 @@ std::error_code BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error(InvalidType); + return Error(BitcodeError::InvalidType); ResultTy = StructType::get(Context, EltTys, Record[0]); break; } case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] if (ConvertToString(Record, 0, TypeName)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); continue; case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (NumRecords >= TypeList.size()) - return Error(InvalidTYPETable); + return Error(BitcodeError::InvalidTYPETable); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); @@ -899,17 +932,17 @@ std::error_code BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Res->setBody(EltTys, Record[0]); ResultTy = Res; break; } case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] if (Record.size() != 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (NumRecords >= TypeList.size()) - return Error(InvalidTYPETable); + return Error(BitcodeError::InvalidTYPETable); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); @@ -924,24 +957,24 @@ std::error_code BitcodeReader::ParseTypeTableBody() { } case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = ArrayType::get(ResultTy, Record[0]); else - return Error(InvalidType); + return Error(BitcodeError::InvalidType); break; case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = VectorType::get(ResultTy, Record[0]); else - return Error(InvalidType); + return Error(BitcodeError::InvalidType); break; } if (NumRecords >= TypeList.size()) - return Error(InvalidTYPETable); + return Error(BitcodeError::InvalidTYPETable); assert(ResultTy && "Didn't read a type?"); assert(!TypeList[NumRecords] && "Already read type?"); TypeList[NumRecords++] = ResultTy; @@ -950,7 +983,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { std::error_code BitcodeReader::ParseValueSymbolTable() { if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -962,7 +995,7 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -977,10 +1010,10 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { break; case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] if (ConvertToString(Record, 1, ValueName)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned ValueID = Record[0]; if (ValueID >= ValueList.size() || !ValueList[ValueID]) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Value *V = ValueList[ValueID]; V->setName(StringRef(ValueName.data(), ValueName.size())); @@ -989,10 +1022,10 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { } case bitc::VST_CODE_BBENTRY: { if (ConvertToString(Record, 1, ValueName)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); BasicBlock *BB = getBasicBlock(Record[0]); if (!BB) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); BB->setName(StringRef(ValueName.data(), ValueName.size())); ValueName.clear(); @@ -1006,7 +1039,7 @@ std::error_code BitcodeReader::ParseMetadata() { unsigned NextMDValueNo = MDValueList.size(); if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -1017,7 +1050,7 @@ std::error_code BitcodeReader::ParseMetadata() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -1048,7 +1081,7 @@ std::error_code BitcodeReader::ParseMetadata() { for (unsigned i = 0; i != Size; ++i) { MDNode *MD = dyn_cast_or_null<MDNode>(MDValueList.getValueFwdRef(Record[i])); if (!MD) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); NMD->addOperand(MD); } break; @@ -1058,14 +1091,14 @@ std::error_code BitcodeReader::ParseMetadata() { // fall-through case bitc::METADATA_NODE: { if (Record.size() % 2 == 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned Size = Record.size(); SmallVector<Value*, 8> Elts; for (unsigned i = 0; i != Size; i += 2) { Type *Ty = getTypeByID(Record[i]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (Ty->isMetadataTy()) Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); else if (!Ty->isVoidTy()) @@ -1087,14 +1120,14 @@ std::error_code BitcodeReader::ParseMetadata() { } case bitc::METADATA_KIND: { if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned Kind = Record[0]; SmallString<8> Name(Record.begin()+1, Record.end()); unsigned NewKind = TheModule->getMDKindID(Name.str()); if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) - return Error(ConflictingMETADATA_KINDRecords); + return Error(BitcodeError::ConflictingMETADATA_KINDRecords); break; } } @@ -1132,7 +1165,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) GlobalInitWorklist.back().first->setInitializer(C); else - return Error(ExpectedConstant); + return Error(BitcodeError::ExpectedConstant); } GlobalInitWorklist.pop_back(); } @@ -1145,7 +1178,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) AliasInitWorklist.back().first->setAliasee(C); else - return Error(ExpectedConstant); + return Error(BitcodeError::ExpectedConstant); } AliasInitWorklist.pop_back(); } @@ -1158,7 +1191,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) FunctionPrefixWorklist.back().first->setPrefixData(C); else - return Error(ExpectedConstant); + return Error(BitcodeError::ExpectedConstant); } FunctionPrefixWorklist.pop_back(); } @@ -1176,7 +1209,7 @@ static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { std::error_code BitcodeReader::ParseConstants() { if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -1189,10 +1222,10 @@ std::error_code BitcodeReader::ParseConstants() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: if (NextCstNo != ValueList.size()) - return Error(InvalidConstantReference); + return Error(BitcodeError::InvalidConstantReference); // Once all the constants have been read, go through and resolve forward // references. @@ -1214,9 +1247,9 @@ std::error_code BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (Record[0] >= TypeList.size() || !TypeList[Record[0]]) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); CurTy = TypeList[Record[0]]; continue; // Skip the ValueList manipulation. case bitc::CST_CODE_NULL: // NULL @@ -1224,12 +1257,12 @@ std::error_code BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_INTEGER: // INTEGER: [intval] if (!CurTy->isIntegerTy() || Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); break; case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] if (!CurTy->isIntegerTy() || Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); APInt VInt = ReadWideAPInt(Record, cast<IntegerType>(CurTy)->getBitWidth()); @@ -1239,7 +1272,7 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (CurTy->isHalfTy()) V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, APInt(16, (uint16_t)Record[0]))); @@ -1269,7 +1302,7 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned Size = Record.size(); SmallVector<Constant*, 16> Elts; @@ -1297,7 +1330,7 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_STRING: // STRING: [values] case bitc::CST_CODE_CSTRING: { // CSTRING: [values] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallString<16> Elts(Record.begin(), Record.end()); V = ConstantDataArray::getString(Context, Elts, @@ -1306,7 +1339,7 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_DATA: {// DATA: [n x value] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *EltTy = cast<SequentialType>(CurTy)->getElementType(); unsigned Size = Record.size(); @@ -1351,14 +1384,14 @@ std::error_code BitcodeReader::ParseConstants() { else V = ConstantDataArray::get(Context, Elts); } else { - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); } break; } case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); if (Opc < 0) { V = UndefValue::get(CurTy); // Unknown binop. @@ -1389,14 +1422,14 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); int Opc = GetDecodedCastOpcode(Record[0]); if (Opc < 0) { V = UndefValue::get(CurTy); // Unknown cast. } else { Type *OpTy = getTypeByID(Record[1]); if (!OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); V = UpgradeBitCastExpr(Opc, Op, CurTy); if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy); @@ -1406,12 +1439,12 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_CE_INBOUNDS_GEP: case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] if (Record.size() & 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Constant*, 16> Elts; for (unsigned i = 0, e = Record.size(); i != e; i += 2) { Type *ElTy = getTypeByID(Record[i]); if (!ElTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); } ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); @@ -1422,7 +1455,7 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *SelectorTy = Type::getInt1Ty(Context); @@ -1441,22 +1474,22 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_CE_EXTRACTELT : { // CE_EXTRACTELT: [opty, opval, opty, opval] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); if (!OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = nullptr; if (Record.size() == 4) { Type *IdxTy = getTypeByID(Record[2]); if (!IdxTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy); } else // TODO: Remove with llvm 4.0 Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); if (!Op1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); V = ConstantExpr::getExtractElement(Op0, Op1); break; } @@ -1464,7 +1497,7 @@ std::error_code BitcodeReader::ParseConstants() { : { // CE_INSERTELT: [opval, opval, opty, opval] VectorType *OpTy = dyn_cast<VectorType>(CurTy); if (Record.size() < 3 || !OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy->getElementType()); @@ -1472,19 +1505,19 @@ std::error_code BitcodeReader::ParseConstants() { if (Record.size() == 4) { Type *IdxTy = getTypeByID(Record[2]); if (!IdxTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy); } else // TODO: Remove with llvm 4.0 Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); if (!Op2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); V = ConstantExpr::getInsertElement(Op0, Op1, Op2); break; } case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] VectorType *OpTy = dyn_cast<VectorType>(CurTy); if (Record.size() < 3 || !OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1498,7 +1531,7 @@ std::error_code BitcodeReader::ParseConstants() { VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); if (Record.size() < 4 || !RTy || !OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1509,10 +1542,10 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] if (Record.size() < 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); if (!OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); @@ -1526,16 +1559,16 @@ std::error_code BitcodeReader::ParseConstants() { // FIXME: Remove with the 4.0 release. case bitc::CST_CODE_INLINEASM_OLD: { if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); std::string AsmStr, ConstrStr; bool HasSideEffects = Record[0] & 1; bool IsAlignStack = Record[0] >> 1; unsigned AsmStrSize = Record[1]; if (2+AsmStrSize >= Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1550,17 +1583,17 @@ std::error_code BitcodeReader::ParseConstants() { // inteldialect). case bitc::CST_CODE_INLINEASM: { if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); std::string AsmStr, ConstrStr; bool HasSideEffects = Record[0] & 1; bool IsAlignStack = (Record[0] >> 1) & 1; unsigned AsmDialect = Record[0] >> 2; unsigned AsmStrSize = Record[1]; if (2+AsmStrSize >= Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1574,35 +1607,46 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_BLOCKADDRESS:{ if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *FnTy = getTypeByID(Record[0]); if (!FnTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Function *Fn = dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); if (!Fn) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); + + // Don't let Fn get dematerialized. + BlockAddressesTaken.insert(Fn); // If the function is already parsed we can insert the block address right // away. + BasicBlock *BB; + unsigned BBID = Record[2]; + if (!BBID) + // Invalid reference to entry block. + return Error(BitcodeError::InvalidID); if (!Fn->empty()) { Function::iterator BBI = Fn->begin(), BBE = Fn->end(); - for (size_t I = 0, E = Record[2]; I != E; ++I) { + for (size_t I = 0, E = BBID; I != E; ++I) { if (BBI == BBE) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); ++BBI; } - V = BlockAddress::get(Fn, BBI); + BB = BBI; } else { // Otherwise insert a placeholder and remember it so it can be inserted // when the function is parsed. - GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), - Type::getInt8Ty(Context), - false, GlobalValue::InternalLinkage, - nullptr, ""); - BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); - V = FwdRef; + auto &FwdBBs = BasicBlockFwdRefs[Fn]; + if (FwdBBs.empty()) + BasicBlockFwdRefQueue.push_back(Fn); + if (FwdBBs.size() < BBID + 1) + FwdBBs.resize(BBID + 1); + if (!FwdBBs[BBID]) + FwdBBs[BBID] = BasicBlock::Create(Context); + BB = FwdBBs[BBID]; } + V = BlockAddress::get(Fn, BB); break; } } @@ -1614,18 +1658,17 @@ std::error_code BitcodeReader::ParseConstants() { std::error_code BitcodeReader::ParseUseLists() { if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) - return Error(InvalidRecord); - - SmallVector<uint64_t, 64> Record; + return Error(BitcodeError::InvalidRecord); // Read all the records. + SmallVector<uint64_t, 64> Record; while (1) { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -1635,14 +1678,42 @@ std::error_code BitcodeReader::ParseUseLists() { // Read a use list record. Record.clear(); + bool IsBB = false; switch (Stream.readRecord(Entry.ID, Record)) { default: // Default behavior: unknown type. break; - case bitc::USELIST_CODE_ENTRY: { // USELIST_CODE_ENTRY: TBD. + case bitc::USELIST_CODE_BB: + IsBB = true; + // fallthrough + case bitc::USELIST_CODE_DEFAULT: { unsigned RecordLength = Record.size(); - if (RecordLength < 1) - return Error(InvalidRecord); - UseListRecords.push_back(Record); + if (RecordLength < 3) + // Records should have at least an ID and two indexes. + return Error(BitcodeError::InvalidRecord); + unsigned ID = Record.back(); + Record.pop_back(); + + Value *V; + if (IsBB) { + assert(ID < FunctionBBs.size() && "Basic block not found"); + V = FunctionBBs[ID]; + } else + V = ValueList[ID]; + unsigned NumUses = 0; + SmallDenseMap<const Use *, unsigned, 16> Order; + for (const Use &U : V->uses()) { + if (++NumUses > Record.size()) + break; + Order[&U] = Record[NumUses - 1]; + } + if (Order.size() != Record.size() || NumUses > Record.size()) + // Mismatches can happen if the functions are being materialized lazily + // (out-of-order), or a value has been upgraded. + break; + + V->sortUseList([&](const Use &L, const Use &R) { + return Order.lookup(&L) < Order.lookup(&R); + }); break; } } @@ -1655,7 +1726,7 @@ std::error_code BitcodeReader::ParseUseLists() { std::error_code BitcodeReader::RememberAndSkipFunctionBody() { // Get the function we are talking about. if (FunctionsWithBodies.empty()) - return Error(InsufficientFunctionProtos); + return Error(BitcodeError::InsufficientFunctionProtos); Function *Fn = FunctionsWithBodies.back(); FunctionsWithBodies.pop_back(); @@ -1666,7 +1737,7 @@ std::error_code BitcodeReader::RememberAndSkipFunctionBody() { // Skip over the function block for now. if (Stream.SkipBlock()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); return std::error_code(); } @@ -1674,7 +1745,7 @@ std::error_code BitcodeReader::GlobalCleanup() { // Patch the initializers for globals and aliases up. ResolveGlobalAndAliasInits(); if (!GlobalInits.empty() || !AliasInits.empty()) - return Error(MalformedGlobalInitializerSet); + return Error(BitcodeError::MalformedGlobalInitializerSet); // Look for intrinsic functions which need to be upgraded at some point for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); @@ -1703,7 +1774,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { if (Resume) Stream.JumpToBit(NextUnreadBit); else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; std::vector<std::string> SectionTable; @@ -1715,7 +1786,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return GlobalCleanup(); @@ -1723,11 +1794,11 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); break; case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); break; case bitc::PARAMATTR_BLOCK_ID: if (std::error_code EC = ParseAttributeBlock()) @@ -1797,12 +1868,12 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { default: break; // Default behavior, ignore unknown content. case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // Only version #0 and #1 are supported so far. unsigned module_version = Record[0]; switch (module_version) { default: - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); case 0: UseRelativeIDs = false; break; @@ -1815,21 +1886,21 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); TheModule->setTargetTriple(S); break; } case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); TheModule->setDataLayout(S); break; } case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); TheModule->setModuleInlineAsm(S); break; } @@ -1837,27 +1908,27 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // FIXME: Remove in 4.0. std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // Ignore value. break; } case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SectionTable.push_back(S); break; } case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); GCTable.push_back(S); break; } case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]); unsigned ComdatNameSize = Record[1]; std::string ComdatName; @@ -1874,12 +1945,12 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // unnamed_addr, dllstorageclass] case bitc::MODULE_CODE_GLOBALVAR: { if (Record.size() < 6) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (!Ty->isPointerTy()) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); Ty = cast<PointerType>(Ty)->getElementType(); @@ -1889,7 +1960,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { std::string Section; if (Record[5]) { if (Record[5]-1 >= SectionTable.size()) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); Section = SectionTable[Record[5]-1]; } GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; @@ -1942,16 +2013,16 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // dllstorageclass] case bitc::MODULE_CODE_FUNCTION: { if (Record.size() < 8) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (!Ty->isPointerTy()) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); FunctionType *FTy = dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); if (!FTy) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, "", TheModule); @@ -1964,7 +2035,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { Func->setAlignment((1 << Record[5]) >> 1); if (Record[6]) { if (Record[6]-1 >= SectionTable.size()) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); Func->setSection(SectionTable[Record[6]-1]); } // Local linkage must have default visibility. @@ -1973,7 +2044,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { Func->setVisibility(GetDecodedVisibility(Record[7])); if (Record.size() > 8 && Record[8]) { if (Record[8]-1 > GCTable.size()) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); Func->setGC(GCTable[Record[8]-1].c_str()); } bool UnnamedAddr = false; @@ -1999,8 +2070,10 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // If this is a function with a body, remember the prototype we are // creating now, so that we can match up the body with them later. if (!isProto) { + Func->setIsMaterializable(true); FunctionsWithBodies.push_back(Func); - if (LazyStreamer) DeferredFunctionInfo[Func] = 0; + if (LazyStreamer) + DeferredFunctionInfo[Func] = 0; } break; } @@ -2008,13 +2081,13 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass] case bitc::MODULE_CODE_ALIAS: { if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); auto *PTy = dyn_cast<PointerType>(Ty); if (!PTy) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); auto *NewGA = GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), @@ -2029,9 +2102,9 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { else UpgradeDLLImportExportLinkage(NewGA, Record[2]); if (Record.size() > 5) - NewGA->setThreadLocalMode(GetDecodedThreadLocalMode(Record[5])); + NewGA->setThreadLocalMode(GetDecodedThreadLocalMode(Record[5])); if (Record.size() > 6) - NewGA->setUnnamedAddr(Record[6]); + NewGA->setUnnamedAddr(Record[6]); ValueList.push_back(NewGA); AliasInits.push_back(std::make_pair(NewGA, Record[1])); break; @@ -2040,7 +2113,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { case bitc::MODULE_CODE_PURGEVALS: // Trim down the value list to the specified size. if (Record.size() < 1 || Record[0] > ValueList.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); ValueList.shrinkTo(Record[0]); break; } @@ -2061,7 +2134,7 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error(InvalidBitcodeSignature); + return Error(BitcodeError::InvalidBitcodeSignature); // We expect a number of well-defined blocks, though we don't necessarily // need to understand them all. @@ -2074,7 +2147,7 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); @@ -2082,12 +2155,12 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { switch (Entry.ID) { case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); break; case bitc::MODULE_BLOCK_ID: // Reject multiple MODULE_BLOCK's in a single bitstream. if (TheModule) - return Error(InvalidMultipleBlocks); + return Error(BitcodeError::InvalidMultipleBlocks); TheModule = M; if (std::error_code EC = ParseModule(false)) return EC; @@ -2096,7 +2169,7 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { break; default: if (Stream.SkipBlock()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); break; } continue; @@ -2111,14 +2184,14 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { Stream.AtEndOfStream()) return std::error_code(); - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } } } ErrorOr<std::string> BitcodeReader::parseModuleTriple() { if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -2130,7 +2203,7 @@ ErrorOr<std::string> BitcodeReader::parseModuleTriple() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return Triple; case BitstreamEntry::Record: @@ -2144,7 +2217,7 @@ ErrorOr<std::string> BitcodeReader::parseModuleTriple() { case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Triple = S; break; } @@ -2165,7 +2238,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error(InvalidBitcodeSignature); + return Error(BitcodeError::InvalidBitcodeSignature); // We expect a number of well-defined blocks, though we don't necessarily // need to understand them all. @@ -2174,7 +2247,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); @@ -2184,7 +2257,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { // Ignore other sub-blocks. if (Stream.SkipBlock()) - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); continue; case BitstreamEntry::Record: @@ -2197,7 +2270,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { /// ParseMetadataAttachment - Parse metadata attachments. std::error_code BitcodeReader::ParseMetadataAttachment() { if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; while (1) { @@ -2206,7 +2279,7 @@ std::error_code BitcodeReader::ParseMetadataAttachment() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -2222,14 +2295,14 @@ std::error_code BitcodeReader::ParseMetadataAttachment() { case bitc::METADATA_ATTACHMENT: { unsigned RecordLength = Record.size(); if (Record.empty() || (RecordLength - 1) % 2 == 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Instruction *Inst = InstructionList[Record[0]]; for (unsigned i = 1; i != RecordLength; i = i+2) { unsigned Kind = Record[i]; DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind); if (I == MDKindMap.end()) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); Value *Node = MDValueList.getValueFwdRef(Record[i+1]); Inst->setMetadata(I->second, cast<MDNode>(Node)); if (I->second == LLVMContext::MD_tbaa) @@ -2244,7 +2317,7 @@ std::error_code BitcodeReader::ParseMetadataAttachment() { /// ParseFunctionBody - Lazily parse the specified function body block. std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); InstructionList.clear(); unsigned ModuleValueListSize = ValueList.size(); @@ -2267,7 +2340,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: goto OutOfRecordLoop; @@ -2275,7 +2348,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); break; case bitc::CONSTANTS_BLOCK_ID: if (std::error_code EC = ParseConstants()) @@ -2294,6 +2367,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (std::error_code EC = ParseMetadata()) return EC; break; + case bitc::USELIST_BLOCK_ID: + if (std::error_code EC = ParseUseLists()) + return EC; + break; } continue; @@ -2308,16 +2385,41 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned BitCode = Stream.readRecord(Entry.ID, Record); switch (BitCode) { default: // Default behavior: reject - return Error(InvalidValue); - case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] + return Error(BitcodeError::InvalidValue); + case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks] if (Record.size() < 1 || Record[0] == 0) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // Create all the basic blocks for the function. FunctionBBs.resize(Record[0]); - for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) - FunctionBBs[i] = BasicBlock::Create(Context, "", F); + + // See if anything took the address of blocks in this function. + auto BBFRI = BasicBlockFwdRefs.find(F); + if (BBFRI == BasicBlockFwdRefs.end()) { + for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) + FunctionBBs[i] = BasicBlock::Create(Context, "", F); + } else { + auto &BBRefs = BBFRI->second; + // Check for invalid basic block references. + if (BBRefs.size() > FunctionBBs.size()) + return Error(BitcodeError::InvalidID); + assert(!BBRefs.empty() && "Unexpected empty array"); + assert(!BBRefs.front() && "Invalid reference to entry block"); + for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E; + ++I) + if (I < RE && BBRefs[I]) { + BBRefs[I]->insertInto(F); + FunctionBBs[I] = BBRefs[I]; + } else { + FunctionBBs[I] = BasicBlock::Create(Context, "", F); + } + + // Erase from the table. + BasicBlockFwdRefs.erase(BBFRI); + } + CurBB = FunctionBBs[0]; continue; + } case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN // This record indicates that the last instruction is at the same @@ -2332,7 +2434,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { I = &FunctionBBs[CurBBNo-1]->back(); if (!I) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I->setDebugLoc(LastLoc); I = nullptr; continue; @@ -2345,7 +2447,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { !FunctionBBs[CurBBNo-1]->empty()) I = &FunctionBBs[CurBBNo-1]->back(); if (!I || Record.size() < 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned Line = Record[0], Col = Record[1]; unsigned ScopeID = Record[2], IAID = Record[3]; @@ -2365,11 +2467,11 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || OpNum+1 > Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); if (Opc == -1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); InstructionList.push_back(I); if (OpNum < Record.size()) { @@ -2411,12 +2513,12 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *ResTy = getTypeByID(Record[OpNum]); int Opc = GetDecodedCastOpcode(Record[OpNum+1]); if (Opc == -1 || !ResTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Instruction *Temp = nullptr; if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) { if (Temp) { @@ -2434,13 +2536,13 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *BasePtr; if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Value*, 16> GEPIdx; while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); GEPIdx.push_back(Op); } @@ -2456,14 +2558,14 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<unsigned, 4> EXTRACTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); EXTRACTVALIdx.push_back((unsigned)Index); } @@ -2477,17 +2579,17 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Value *Val; if (getValueTypePair(Record, OpNum, NextValueNo, Val)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<unsigned, 4> INSERTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); INSERTVALIdx.push_back((unsigned)Index); } @@ -2504,7 +2606,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = SelectInst::Create(Cond, TrueVal, FalseVal); InstructionList.push_back(I); @@ -2519,18 +2621,18 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || getValueTypePair(Record, OpNum, NextValueNo, Cond)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // select condition can be either i1 or [N x i1] if (VectorType* vector_type = dyn_cast<VectorType>(Cond->getType())) { // expect <n x i1> if (vector_type->getElementType() != Type::getInt1Ty(Context)) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); } else { // expect i1 if (Cond->getType() != Type::getInt1Ty(Context)) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); } I = SelectInst::Create(Cond, TrueVal, FalseVal); @@ -2543,7 +2645,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Vec, *Idx; if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || getValueTypePair(Record, OpNum, NextValueNo, Idx)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = ExtractElementInst::Create(Vec, Idx); InstructionList.push_back(I); break; @@ -2556,7 +2658,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<VectorType>(Vec->getType())->getElementType(), Elt) || getValueTypePair(Record, OpNum, NextValueNo, Idx)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = InsertElementInst::Create(Vec, Elt, Idx); InstructionList.push_back(I); break; @@ -2567,10 +2669,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Vec1, *Vec2, *Mask; if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new ShuffleVectorInst(Vec1, Vec2, Mask); InstructionList.push_back(I); break; @@ -2588,7 +2690,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || OpNum+1 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (LHS->getType()->isFPOrFPVectorTy()) I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); @@ -2610,9 +2712,9 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Op = nullptr; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (OpNum != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = ReturnInst::Create(Context, Op); InstructionList.push_back(I); @@ -2620,10 +2722,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] if (Record.size() != 1 && Record.size() != 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); BasicBlock *TrueDest = getBasicBlock(Record[0]); if (!TrueDest) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (Record.size() == 1) { I = BranchInst::Create(TrueDest); @@ -2634,7 +2736,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Cond = getValue(Record, 2, NextValueNo, Type::getInt1Ty(Context)); if (!FalseDest || !Cond) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = BranchInst::Create(TrueDest, FalseDest, Cond); InstructionList.push_back(I); } @@ -2654,7 +2756,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Cond = getValue(Record, 2, NextValueNo, OpTy); BasicBlock *Default = getBasicBlock(Record[3]); if (!OpTy || !Cond || !Default) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned NumCases = Record[4]; @@ -2706,12 +2808,12 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // Old SwitchInst format without case ranges. if (Record.size() < 3 || (Record.size() & 1) == 0) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Cond = getValue(Record, 1, NextValueNo, OpTy); BasicBlock *Default = getBasicBlock(Record[2]); if (!OpTy || !Cond || !Default) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned NumCases = (Record.size()-3)/2; SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); InstructionList.push_back(SI); @@ -2721,7 +2823,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); if (!CaseVal || !DestBB) { delete SI; - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } SI->addCase(CaseVal, DestBB); } @@ -2730,11 +2832,11 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Address = getValue(Record, 1, NextValueNo, OpTy); if (!OpTy || !Address) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned NumDests = Record.size()-2; IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); InstructionList.push_back(IBI); @@ -2743,7 +2845,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { IBI->addDestination(DestBB); } else { delete IBI; - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } } I = IBI; @@ -2753,7 +2855,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] if (Record.size() < 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; BasicBlock *NormalBB = getBasicBlock(Record[2]); @@ -2762,7 +2864,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 4; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); FunctionType *FTy = !CalleeTy ? nullptr : @@ -2771,25 +2873,25 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // Check that the right number of fixed parameters are here. if (!FTy || !NormalBB || !UnwindBB || Record.size() < OpNum+FTy->getNumParams()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Value*, 16> Ops; for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { Ops.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i))); if (!Ops.back()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } if (!FTy->isVarArg()) { if (Record.size() != OpNum) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } else { // Read type/value pairs for varargs params. while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Ops.push_back(Op); } } @@ -2805,7 +2907,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned Idx = 0; Value *Val = nullptr; if (getValueTypePair(Record, Idx, NextValueNo, Val)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = ResumeInst::Create(Val); InstructionList.push_back(I); break; @@ -2816,10 +2918,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { break; case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] if (Record.size() < 1 || ((Record.size()-1)&1)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); InstructionList.push_back(PN); @@ -2835,7 +2937,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { V = getValue(Record, 1+i, NextValueNo, Ty); BasicBlock *BB = getBasicBlock(Record[2+i]); if (!V || !BB) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PN->addIncoming(V, BB); } I = PN; @@ -2846,13 +2948,13 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] unsigned Idx = 0; if (Record.size() < 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[Idx++]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Value *PersFn = nullptr; if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); bool IsCleanup = !!Record[Idx++]; unsigned NumClauses = Record[Idx++]; @@ -2865,7 +2967,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, Idx, NextValueNo, Val)) { delete LP; - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } assert((CT != LandingPadInst::Catch || @@ -2884,15 +2986,19 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] if (Record.size() != 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PointerType *Ty = dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); Type *OpTy = getTypeByID(Record[1]); Value *Size = getFnValueByID(Record[2], OpTy); - unsigned Align = Record[3]; + unsigned AlignRecord = Record[3]; + bool InAlloca = AlignRecord & (1 << 5); + unsigned Align = AlignRecord & ((1 << 5) - 1); if (!Ty || !Size) - return Error(InvalidRecord); - I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); + return Error(BitcodeError::InvalidRecord); + AllocaInst *AI = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); + AI->setUsedWithInAlloca(InAlloca); + I = AI; InstructionList.push_back(I); break; } @@ -2901,7 +3007,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -2913,15 +3019,14 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+4 != Record.size()) - return Error(InvalidRecord); - + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Release || Ordering == AcquireRelease) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, @@ -2936,7 +3041,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+2 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -2950,15 +3055,15 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Acquire || Ordering == AcquireRelease) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, Ordering, SynchScope); @@ -2976,10 +3081,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), New) || (Record.size() < OpNum + 3 || Record.size() > OpNum + 5)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicOrdering SuccessOrdering = GetDecodedOrdering(Record[OpNum+1]); if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); AtomicOrdering FailureOrdering; @@ -3014,14 +3119,14 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); if (Operation < AtomicRMWInst::FIRST_BINOP || Operation > AtomicRMWInst::LAST_BINOP) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Unordered) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); @@ -3030,11 +3135,11 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] if (2 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); if (Ordering == NotAtomic || Ordering == Unordered || Ordering == Monotonic) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); I = new FenceInst(Context, Ordering, SynchScope); InstructionList.push_back(I); @@ -3043,7 +3148,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_CALL: { // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; @@ -3051,13 +3156,13 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 2; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); FunctionType *FTy = nullptr; if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); if (!FTy || Record.size() < FTy->getNumParams()+OpNum) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Value*, 16> Args; // Read the fixed params. @@ -3068,18 +3173,18 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Args.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i))); if (!Args.back()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } // Read type/value pairs for varargs params. if (!FTy->isVarArg()) { if (OpNum != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } else { while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Args.push_back(Op); } } @@ -3099,12 +3204,12 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Op = getValue(Record, 1, NextValueNo, OpTy); Type *ResTy = getTypeByID(Record[2]); if (!OpTy || !Op || !ResTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new VAArgInst(Op, ResTy); InstructionList.push_back(I); break; @@ -3115,7 +3220,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // this file. if (!CurBB) { delete I; - return Error(InvalidInstructionWithNoBB); + return Error(BitcodeError::InvalidInstructionWithNoBB); } CurBB->getInstList().push_back(I); @@ -3142,32 +3247,13 @@ OutOfRecordLoop: delete A; } } - return Error(NeverResolvedValueFoundInFunction); + return Error(BitcodeError::NeverResolvedValueFoundInFunction); } } // FIXME: Check for unresolved forward-declared metadata references // and clean up leaks. - // See if anything took the address of blocks in this function. If so, - // resolve them now. - DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = - BlockAddrFwdRefs.find(F); - if (BAFRI != BlockAddrFwdRefs.end()) { - std::vector<BlockAddrRefTy> &RefList = BAFRI->second; - for (unsigned i = 0, e = RefList.size(); i != e; ++i) { - unsigned BlockIdx = RefList[i].first; - if (BlockIdx >= FunctionBBs.size()) - return Error(InvalidID); - - GlobalVariable *FwdRef = RefList[i].second; - FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); - FwdRef->eraseFromParent(); - } - - BlockAddrFwdRefs.erase(BAFRI); - } - // Trim the value list down to the size it was before we parsed this function. ValueList.shrinkTo(ModuleValueListSize); MDValueList.shrinkTo(ModuleMDValueListSize); @@ -3181,7 +3267,7 @@ std::error_code BitcodeReader::FindFunctionInStream( DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) { while (DeferredFunctionInfoIterator->second == 0) { if (Stream.AtEndOfStream()) - return Error(CouldNotFindFunctionInStream); + return Error(BitcodeError::CouldNotFindFunctionInStream); // ParseModule will parse the next body in the stream and set its // position in the DeferredFunctionInfo map. if (std::error_code EC = ParseModule(true)) @@ -3196,15 +3282,7 @@ std::error_code BitcodeReader::FindFunctionInStream( void BitcodeReader::releaseBuffer() { Buffer.release(); } -bool BitcodeReader::isMaterializable(const GlobalValue *GV) const { - if (const Function *F = dyn_cast<Function>(GV)) { - return F->isDeclaration() && - DeferredFunctionInfo.count(const_cast<Function*>(F)); - } - return false; -} - -std::error_code BitcodeReader::Materialize(GlobalValue *GV) { +std::error_code BitcodeReader::materialize(GlobalValue *GV) { Function *F = dyn_cast<Function>(GV); // If it's not a function or is already material, ignore the request. if (!F || !F->isMaterializable()) @@ -3223,6 +3301,7 @@ std::error_code BitcodeReader::Materialize(GlobalValue *GV) { if (std::error_code EC = ParseFunctionBody(F)) return EC; + F->setIsMaterializable(false); // Upgrade any old intrinsic calls in the function. for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), @@ -3236,13 +3315,21 @@ std::error_code BitcodeReader::Materialize(GlobalValue *GV) { } } - return std::error_code(); + // Bring in any functions that this function forward-referenced via + // blockaddresses. + return materializeForwardReferencedFunctions(); } bool BitcodeReader::isDematerializable(const GlobalValue *GV) const { const Function *F = dyn_cast<Function>(GV); if (!F || F->isDeclaration()) return false; + + // Dematerializing F would leave dangling references that wouldn't be + // reconnected on re-materialization. + if (BlockAddressesTaken.count(F)) + return false; + return DeferredFunctionInfo.count(const_cast<Function*>(F)); } @@ -3255,20 +3342,23 @@ void BitcodeReader::Dematerialize(GlobalValue *GV) { assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); // Just forget the function body, we can remat it later. - F->deleteBody(); + F->dropAllReferences(); + F->setIsMaterializable(true); } std::error_code BitcodeReader::MaterializeModule(Module *M) { assert(M == TheModule && "Can only Materialize the Module this BitcodeReader is attached to."); + + // Promise to materialize all forward references. + WillMaterializeAllForwardRefs = true; + // Iterate over the module, deserializing any functions that are still on // disk. for (Module::iterator F = TheModule->begin(), E = TheModule->end(); F != E; ++F) { - if (F->isMaterializable()) { - if (std::error_code EC = Materialize(F)) - return EC; - } + if (std::error_code EC = materialize(F)) + return EC; } // At this point, if there are any function bodies, the current bit is // pointing to the END_BLOCK record after them. Now make sure the rest @@ -3276,6 +3366,11 @@ std::error_code BitcodeReader::MaterializeModule(Module *M) { if (NextUnreadBit) ParseModule(true); + // Check that all block address forward references got resolved (as we + // promised above). + if (!BasicBlockFwdRefs.empty()) + return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress); + // Upgrade any intrinsic calls that slipped through (should not happen!) and // delete the old functions to clean up. We can't do this unless the entire // module is materialized because there could always be another function body @@ -3312,21 +3407,17 @@ std::error_code BitcodeReader::InitStreamFromBuffer() { const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); - if (Buffer->getBufferSize() & 3) { - if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) - return Error(InvalidBitcodeSignature); - else - return Error(BitcodeStreamInvalidSize); - } + if (Buffer->getBufferSize() & 3) + return Error(BitcodeError::InvalidBitcodeSignature); // If we have a wrapper header, parse it and ignore the non-bc file contents. // The magic number is 0x0B17C0DE stored in little endian. if (isBitcodeWrapper(BufPtr, BufEnd)) if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) - return Error(InvalidBitcodeWrapperHeader); + return Error(BitcodeError::InvalidBitcodeWrapperHeader); StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); - Stream.init(*StreamFile); + Stream.init(&*StreamFile); return std::error_code(); } @@ -3336,14 +3427,14 @@ std::error_code BitcodeReader::InitLazyStream() { // see it. StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); StreamFile.reset(new BitstreamReader(Bytes)); - Stream.init(*StreamFile); + Stream.init(&*StreamFile); unsigned char buf[16]; - if (Bytes->readBytes(0, 16, buf) == -1) - return Error(BitcodeStreamInvalidSize); + if (Bytes->readBytes(buf, 16, 0) != 16) + return Error(BitcodeError::InvalidBitcodeSignature); if (!isBitcode(buf, buf + 16)) - return Error(InvalidBitcodeSignature); + return Error(BitcodeError::InvalidBitcodeSignature); if (isBitcodeWrapper(buf, buf + 4)) { const unsigned char *bitcodeStart = buf; @@ -3361,45 +3452,45 @@ class BitcodeErrorCategoryType : public std::error_category { return "llvm.bitcode"; } std::string message(int IE) const override { - BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE); + BitcodeError E = static_cast<BitcodeError>(IE); switch (E) { - case BitcodeReader::BitcodeStreamInvalidSize: - return "Bitcode stream length should be >= 16 bytes and a multiple of 4"; - case BitcodeReader::ConflictingMETADATA_KINDRecords: + case BitcodeError::ConflictingMETADATA_KINDRecords: return "Conflicting METADATA_KIND records"; - case BitcodeReader::CouldNotFindFunctionInStream: + case BitcodeError::CouldNotFindFunctionInStream: return "Could not find function in stream"; - case BitcodeReader::ExpectedConstant: + case BitcodeError::ExpectedConstant: return "Expected a constant"; - case BitcodeReader::InsufficientFunctionProtos: + case BitcodeError::InsufficientFunctionProtos: return "Insufficient function protos"; - case BitcodeReader::InvalidBitcodeSignature: + case BitcodeError::InvalidBitcodeSignature: return "Invalid bitcode signature"; - case BitcodeReader::InvalidBitcodeWrapperHeader: + case BitcodeError::InvalidBitcodeWrapperHeader: return "Invalid bitcode wrapper header"; - case BitcodeReader::InvalidConstantReference: + case BitcodeError::InvalidConstantReference: return "Invalid ronstant reference"; - case BitcodeReader::InvalidID: + case BitcodeError::InvalidID: return "Invalid ID"; - case BitcodeReader::InvalidInstructionWithNoBB: + case BitcodeError::InvalidInstructionWithNoBB: return "Invalid instruction with no BB"; - case BitcodeReader::InvalidRecord: + case BitcodeError::InvalidRecord: return "Invalid record"; - case BitcodeReader::InvalidTypeForValue: + case BitcodeError::InvalidTypeForValue: return "Invalid type for value"; - case BitcodeReader::InvalidTYPETable: + case BitcodeError::InvalidTYPETable: return "Invalid TYPE table"; - case BitcodeReader::InvalidType: + case BitcodeError::InvalidType: return "Invalid type"; - case BitcodeReader::MalformedBlock: + case BitcodeError::MalformedBlock: return "Malformed block"; - case BitcodeReader::MalformedGlobalInitializerSet: + case BitcodeError::MalformedGlobalInitializerSet: return "Malformed global initializer set"; - case BitcodeReader::InvalidMultipleBlocks: + case BitcodeError::InvalidMultipleBlocks: return "Invalid multiple blocks"; - case BitcodeReader::NeverResolvedValueFoundInFunction: + case BitcodeError::NeverResolvedValueFoundInFunction: return "Never resolved value found in function"; - case BitcodeReader::InvalidValue: + case BitcodeError::NeverResolvedFunctionFromBlockAddress: + return "Never resolved function from blockaddress"; + case BitcodeError::InvalidValue: return "Invalid value"; } llvm_unreachable("Unknown error type!"); @@ -3407,33 +3498,54 @@ class BitcodeErrorCategoryType : public std::error_category { }; } -const std::error_category &BitcodeReader::BitcodeErrorCategory() { - static BitcodeErrorCategoryType O; - return O; +static ManagedStatic<BitcodeErrorCategoryType> ErrorCategory; + +const std::error_category &llvm::BitcodeErrorCategory() { + return *ErrorCategory; } //===----------------------------------------------------------------------===// // External interface //===----------------------------------------------------------------------===// -/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. +/// \brief Get a lazy one-at-time loading module from bitcode. /// -ErrorOr<Module *> llvm::getLazyBitcodeModule(MemoryBuffer *Buffer, - LLVMContext &Context) { +/// This isn't always used in a lazy context. In particular, it's also used by +/// \a parseBitcodeFile(). If this is truly lazy, then we need to eagerly pull +/// in forward-referenced functions from block address references. +/// +/// \param[in] WillMaterializeAll Set to \c true if the caller promises to +/// materialize everything -- in particular, if this isn't truly lazy. +static ErrorOr<Module *> +getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer, + LLVMContext &Context, bool WillMaterializeAll) { Module *M = new Module(Buffer->getBufferIdentifier(), Context); - BitcodeReader *R = new BitcodeReader(Buffer, Context); + BitcodeReader *R = new BitcodeReader(Buffer.get(), Context); M->setMaterializer(R); - if (std::error_code EC = R->ParseBitcodeInto(M)) { + + auto cleanupOnError = [&](std::error_code EC) { R->releaseBuffer(); // Never take ownership on error. delete M; // Also deletes R. return EC; - } + }; + + if (std::error_code EC = R->ParseBitcodeInto(M)) + return cleanupOnError(EC); - R->materializeForwardReferencedFunctions(); + if (!WillMaterializeAll) + // Resolve forward references from blockaddresses. + if (std::error_code EC = R->materializeForwardReferencedFunctions()) + return cleanupOnError(EC); + Buffer.release(); // The BitcodeReader owns it now. return M; } +ErrorOr<Module *> +llvm::getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer, + LLVMContext &Context) { + return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false); +} Module *llvm::getStreamedBitcodeModule(const std::string &name, DataStreamer *streamer, @@ -3451,14 +3563,16 @@ Module *llvm::getStreamedBitcodeModule(const std::string &name, return M; } -ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBuffer *Buffer, +ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context) { - ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModule(Buffer, Context); + std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); + ErrorOr<Module *> ModuleOrErr = + getLazyBitcodeModuleImpl(std::move(Buf), Context, true); if (!ModuleOrErr) return ModuleOrErr; Module *M = ModuleOrErr.get(); // Read in the entire module, and destroy the BitcodeReader. - if (std::error_code EC = M->materializeAllPermanently(true)) { + if (std::error_code EC = M->materializeAllPermanently()) { delete M; return EC; } @@ -3469,12 +3583,11 @@ ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBuffer *Buffer, return M; } -std::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer, +std::string llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context) { - BitcodeReader *R = new BitcodeReader(Buffer, Context); + std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); + auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context); ErrorOr<std::string> Triple = R->parseTriple(); - R->releaseBuffer(); - delete R; if (Triple.getError()) return ""; return Triple.get(); |