diff options
Diffstat (limited to 'contrib/llvm/lib/Bitcode/Reader')
| -rw-r--r-- | contrib/llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 928 | ||||
| -rw-r--r-- | contrib/llvm/lib/Bitcode/Reader/BitcodeReader.h | 104 | ||||
| -rw-r--r-- | contrib/llvm/lib/Bitcode/Reader/BitstreamReader.cpp | 13 |
3 files changed, 659 insertions, 386 deletions
diff --git a/contrib/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/contrib/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index e6ff4b4..ce3b7d1 100644 --- a/contrib/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/contrib/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -12,16 +12,19 @@ #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" #include "llvm/AutoUpgrade.h" +#include "llvm/Bitcode/LLVMBitCodes.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/IntrinsicInst.h" +#include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" #include "llvm/IR/OperandTraits.h" #include "llvm/IR/Operator.h" #include "llvm/Support/DataStream.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/raw_ostream.h" using namespace llvm; enum { @@ -87,7 +90,6 @@ static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { case 12: return GlobalValue::AvailableExternallyLinkage; case 13: return GlobalValue::LinkerPrivateLinkage; case 14: return GlobalValue::LinkerPrivateWeakLinkage; - case 15: return GlobalValue::LinkOnceODRAutoHideLinkage; } } @@ -126,6 +128,7 @@ static int GetDecodedCastOpcode(unsigned Val) { case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; case bitc::CAST_BITCAST : return Instruction::BitCast; + case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast; } } static int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { @@ -448,12 +451,12 @@ static void decodeLLVMAttributesForBitcode(AttrBuilder &B, (EncodedAttrs & 0xffff)); } -bool BitcodeReader::ParseAttributeBlock() { +error_code BitcodeReader::ParseAttributeBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); if (!MAttributes.empty()) - return Error("Multiple PARAMATTR blocks found!"); + return Error(InvalidMultipleBlocks); SmallVector<uint64_t, 64> Record; @@ -466,9 +469,9 @@ bool BitcodeReader::ParseAttributeBlock() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("Error at end of PARAMATTR block"); + return Error(MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return error_code::success(); case BitstreamEntry::Record: // The interesting case. break; @@ -482,7 +485,7 @@ bool BitcodeReader::ParseAttributeBlock() { case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] // FIXME: Remove in 4.0. if (Record.size() & 1) - return Error("Invalid ENTRY record"); + return Error(InvalidRecord); for (unsigned i = 0, e = Record.size(); i != e; i += 2) { AttrBuilder B; @@ -506,12 +509,102 @@ bool BitcodeReader::ParseAttributeBlock() { } } -bool BitcodeReader::ParseAttributeGroupBlock() { +// Returns Attribute::None on unrecognized codes. +static Attribute::AttrKind GetAttrFromCode(uint64_t Code) { + switch (Code) { + default: + return Attribute::None; + case bitc::ATTR_KIND_ALIGNMENT: + return Attribute::Alignment; + case bitc::ATTR_KIND_ALWAYS_INLINE: + return Attribute::AlwaysInline; + case bitc::ATTR_KIND_BUILTIN: + return Attribute::Builtin; + case bitc::ATTR_KIND_BY_VAL: + return Attribute::ByVal; + case bitc::ATTR_KIND_COLD: + return Attribute::Cold; + case bitc::ATTR_KIND_INLINE_HINT: + return Attribute::InlineHint; + case bitc::ATTR_KIND_IN_REG: + return Attribute::InReg; + case bitc::ATTR_KIND_MIN_SIZE: + return Attribute::MinSize; + case bitc::ATTR_KIND_NAKED: + return Attribute::Naked; + case bitc::ATTR_KIND_NEST: + return Attribute::Nest; + case bitc::ATTR_KIND_NO_ALIAS: + return Attribute::NoAlias; + case bitc::ATTR_KIND_NO_BUILTIN: + return Attribute::NoBuiltin; + case bitc::ATTR_KIND_NO_CAPTURE: + return Attribute::NoCapture; + case bitc::ATTR_KIND_NO_DUPLICATE: + return Attribute::NoDuplicate; + case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT: + return Attribute::NoImplicitFloat; + case bitc::ATTR_KIND_NO_INLINE: + return Attribute::NoInline; + case bitc::ATTR_KIND_NON_LAZY_BIND: + return Attribute::NonLazyBind; + case bitc::ATTR_KIND_NO_RED_ZONE: + return Attribute::NoRedZone; + case bitc::ATTR_KIND_NO_RETURN: + return Attribute::NoReturn; + case bitc::ATTR_KIND_NO_UNWIND: + return Attribute::NoUnwind; + case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE: + return Attribute::OptimizeForSize; + case bitc::ATTR_KIND_OPTIMIZE_NONE: + return Attribute::OptimizeNone; + case bitc::ATTR_KIND_READ_NONE: + return Attribute::ReadNone; + case bitc::ATTR_KIND_READ_ONLY: + return Attribute::ReadOnly; + case bitc::ATTR_KIND_RETURNED: + return Attribute::Returned; + case bitc::ATTR_KIND_RETURNS_TWICE: + return Attribute::ReturnsTwice; + case bitc::ATTR_KIND_S_EXT: + return Attribute::SExt; + case bitc::ATTR_KIND_STACK_ALIGNMENT: + return Attribute::StackAlignment; + case bitc::ATTR_KIND_STACK_PROTECT: + return Attribute::StackProtect; + case bitc::ATTR_KIND_STACK_PROTECT_REQ: + return Attribute::StackProtectReq; + case bitc::ATTR_KIND_STACK_PROTECT_STRONG: + return Attribute::StackProtectStrong; + case bitc::ATTR_KIND_STRUCT_RET: + return Attribute::StructRet; + case bitc::ATTR_KIND_SANITIZE_ADDRESS: + return Attribute::SanitizeAddress; + case bitc::ATTR_KIND_SANITIZE_THREAD: + return Attribute::SanitizeThread; + case bitc::ATTR_KIND_SANITIZE_MEMORY: + return Attribute::SanitizeMemory; + case bitc::ATTR_KIND_UW_TABLE: + return Attribute::UWTable; + case bitc::ATTR_KIND_Z_EXT: + return Attribute::ZExt; + } +} + +error_code BitcodeReader::ParseAttrKind(uint64_t Code, + Attribute::AttrKind *Kind) { + *Kind = GetAttrFromCode(Code); + if (*Kind == Attribute::None) + return Error(InvalidValue); + return error_code::success(); +} + +error_code BitcodeReader::ParseAttributeGroupBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); if (!MAttributeGroups.empty()) - return Error("Multiple PARAMATTR_GROUP blocks found!"); + return Error(InvalidMultipleBlocks); SmallVector<uint64_t, 64> Record; @@ -522,9 +615,9 @@ bool BitcodeReader::ParseAttributeGroupBlock() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("Error at end of PARAMATTR_GROUP block"); + return Error(MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return error_code::success(); case BitstreamEntry::Record: // The interesting case. break; @@ -537,7 +630,7 @@ bool BitcodeReader::ParseAttributeGroupBlock() { break; case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...] if (Record.size() < 3) - return Error("Invalid ENTRY record"); + return Error(InvalidRecord); uint64_t GrpID = Record[0]; uint64_t Idx = Record[1]; // Index of the object this attribute refers to. @@ -545,9 +638,16 @@ bool BitcodeReader::ParseAttributeGroupBlock() { AttrBuilder B; for (unsigned i = 2, e = Record.size(); i != e; ++i) { if (Record[i] == 0) { // Enum attribute - B.addAttribute(Attribute::AttrKind(Record[++i])); + Attribute::AttrKind Kind; + if (error_code EC = ParseAttrKind(Record[++i], &Kind)) + return EC; + + B.addAttribute(Kind); } else if (Record[i] == 1) { // Align attribute - if (Attribute::AttrKind(Record[++i]) == Attribute::Alignment) + Attribute::AttrKind Kind; + if (error_code EC = ParseAttrKind(Record[++i], &Kind)) + return EC; + if (Kind == Attribute::Alignment) B.addAlignmentAttr(Record[++i]); else B.addStackAlignmentAttr(Record[++i]); @@ -581,16 +681,16 @@ bool BitcodeReader::ParseAttributeGroupBlock() { } } -bool BitcodeReader::ParseTypeTable() { +error_code BitcodeReader::ParseTypeTable() { if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) - return Error("Malformed block record"); + return Error(InvalidRecord); return ParseTypeTableBody(); } -bool BitcodeReader::ParseTypeTableBody() { +error_code BitcodeReader::ParseTypeTableBody() { if (!TypeList.empty()) - return Error("Multiple TYPE_BLOCKs found!"); + return Error(InvalidMultipleBlocks); SmallVector<uint64_t, 64> Record; unsigned NumRecords = 0; @@ -604,12 +704,11 @@ bool BitcodeReader::ParseTypeTableBody() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - Error("Error in the type table block"); - return true; + return Error(MalformedBlock); case BitstreamEntry::EndBlock: if (NumRecords != TypeList.size()) - return Error("Invalid type forward reference in TYPE_BLOCK"); - return false; + return Error(MalformedBlock); + return error_code::success(); case BitstreamEntry::Record: // The interesting case. break; @@ -619,12 +718,13 @@ bool BitcodeReader::ParseTypeTableBody() { Record.clear(); Type *ResultTy = 0; switch (Stream.readRecord(Entry.ID, Record)) { - default: return Error("unknown type in type table"); + default: + return Error(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("Invalid TYPE_CODE_NUMENTRY record"); + return Error(InvalidRecord); TypeList.resize(Record[0]); continue; case bitc::TYPE_CODE_VOID: // VOID @@ -659,19 +759,20 @@ bool BitcodeReader::ParseTypeTableBody() { break; case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] if (Record.size() < 1) - return Error("Invalid Integer type record"); + return Error(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("Invalid POINTER type record"); + return Error(InvalidRecord); unsigned AddressSpace = 0; if (Record.size() == 2) AddressSpace = Record[1]; ResultTy = getTypeByID(Record[0]); - if (ResultTy == 0) return Error("invalid element type in pointer type"); + if (ResultTy == 0) + return Error(InvalidType); ResultTy = PointerType::get(ResultTy, AddressSpace); break; } @@ -679,7 +780,7 @@ bool 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("Invalid FUNCTION type record"); + return Error(InvalidRecord); SmallVector<Type*, 8> ArgTys; for (unsigned i = 3, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -690,7 +791,7 @@ bool BitcodeReader::ParseTypeTableBody() { ResultTy = getTypeByID(Record[2]); if (ResultTy == 0 || ArgTys.size() < Record.size()-3) - return Error("invalid type in function type"); + return Error(InvalidType); ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); break; @@ -698,7 +799,7 @@ bool BitcodeReader::ParseTypeTableBody() { case bitc::TYPE_CODE_FUNCTION: { // FUNCTION: [vararg, retty, paramty x N] if (Record.size() < 2) - return Error("Invalid FUNCTION type record"); + return Error(InvalidRecord); SmallVector<Type*, 8> ArgTys; for (unsigned i = 2, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -709,14 +810,14 @@ bool BitcodeReader::ParseTypeTableBody() { ResultTy = getTypeByID(Record[1]); if (ResultTy == 0 || ArgTys.size() < Record.size()-2) - return Error("invalid type in function type"); + return Error(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("Invalid STRUCT type record"); + return Error(InvalidRecord); SmallVector<Type*, 8> EltTys; for (unsigned i = 1, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -725,21 +826,21 @@ bool BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error("invalid type in struct type"); + return Error(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("Invalid STRUCT_NAME record"); + return Error(InvalidRecord); continue; case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] if (Record.size() < 1) - return Error("Invalid STRUCT type record"); + return Error(InvalidRecord); if (NumRecords >= TypeList.size()) - return Error("invalid TYPE table"); + return Error(InvalidTYPETable); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); @@ -758,17 +859,17 @@ bool BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error("invalid STRUCT type record"); + return Error(InvalidRecord); Res->setBody(EltTys, Record[0]); ResultTy = Res; break; } case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] if (Record.size() != 1) - return Error("Invalid OPAQUE type record"); + return Error(InvalidRecord); if (NumRecords >= TypeList.size()) - return Error("invalid TYPE table"); + return Error(InvalidTYPETable); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); @@ -783,33 +884,33 @@ bool BitcodeReader::ParseTypeTableBody() { } case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] if (Record.size() < 2) - return Error("Invalid ARRAY type record"); + return Error(InvalidRecord); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = ArrayType::get(ResultTy, Record[0]); else - return Error("Invalid ARRAY type element"); + return Error(InvalidType); break; case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] if (Record.size() < 2) - return Error("Invalid VECTOR type record"); + return Error(InvalidRecord); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = VectorType::get(ResultTy, Record[0]); else - return Error("Invalid ARRAY type element"); + return Error(InvalidType); break; } if (NumRecords >= TypeList.size()) - return Error("invalid TYPE table"); + return Error(InvalidTYPETable); assert(ResultTy && "Didn't read a type?"); assert(TypeList[NumRecords] == 0 && "Already read type?"); TypeList[NumRecords++] = ResultTy; } } -bool BitcodeReader::ParseValueSymbolTable() { +error_code BitcodeReader::ParseValueSymbolTable() { if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -821,9 +922,9 @@ bool BitcodeReader::ParseValueSymbolTable() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed value symbol table block"); + return Error(MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return error_code::success(); case BitstreamEntry::Record: // The interesting case. break; @@ -836,10 +937,10 @@ bool BitcodeReader::ParseValueSymbolTable() { break; case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] if (ConvertToString(Record, 1, ValueName)) - return Error("Invalid VST_ENTRY record"); + return Error(InvalidRecord); unsigned ValueID = Record[0]; if (ValueID >= ValueList.size()) - return Error("Invalid Value ID in VST_ENTRY record"); + return Error(InvalidRecord); Value *V = ValueList[ValueID]; V->setName(StringRef(ValueName.data(), ValueName.size())); @@ -848,10 +949,10 @@ bool BitcodeReader::ParseValueSymbolTable() { } case bitc::VST_CODE_BBENTRY: { if (ConvertToString(Record, 1, ValueName)) - return Error("Invalid VST_BBENTRY record"); + return Error(InvalidRecord); BasicBlock *BB = getBasicBlock(Record[0]); if (BB == 0) - return Error("Invalid BB ID in VST_BBENTRY record"); + return Error(InvalidRecord); BB->setName(StringRef(ValueName.data(), ValueName.size())); ValueName.clear(); @@ -861,11 +962,11 @@ bool BitcodeReader::ParseValueSymbolTable() { } } -bool BitcodeReader::ParseMetadata() { +error_code BitcodeReader::ParseMetadata() { unsigned NextMDValueNo = MDValueList.size(); if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -876,10 +977,9 @@ bool BitcodeReader::ParseMetadata() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - Error("malformed metadata block"); - return true; + return Error(MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return error_code::success(); case BitstreamEntry::Record: // The interesting case. break; @@ -908,7 +1008,7 @@ bool BitcodeReader::ParseMetadata() { for (unsigned i = 0; i != Size; ++i) { MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); if (MD == 0) - return Error("Malformed metadata record"); + return Error(InvalidRecord); NMD->addOperand(MD); } break; @@ -918,13 +1018,14 @@ bool BitcodeReader::ParseMetadata() { // fall-through case bitc::METADATA_NODE: { if (Record.size() % 2 == 1) - return Error("Invalid METADATA_NODE record"); + return Error(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("Invalid METADATA_NODE record"); + if (!Ty) + return Error(InvalidRecord); if (Ty->isMetadataTy()) Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); else if (!Ty->isVoidTy()) @@ -945,14 +1046,14 @@ bool BitcodeReader::ParseMetadata() { } case bitc::METADATA_KIND: { if (Record.size() < 2) - return Error("Invalid METADATA_KIND record"); + return Error(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("Conflicting METADATA_KIND records"); + return Error(ConflictingMETADATA_KINDRecords); break; } } @@ -972,12 +1073,14 @@ uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { /// ResolveGlobalAndAliasInits - Resolve all of the initializers for global /// values and aliases that we can. -bool BitcodeReader::ResolveGlobalAndAliasInits() { +error_code BitcodeReader::ResolveGlobalAndAliasInits() { std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; + std::vector<std::pair<Function*, unsigned> > FunctionPrefixWorklist; GlobalInitWorklist.swap(GlobalInits); AliasInitWorklist.swap(AliasInits); + FunctionPrefixWorklist.swap(FunctionPrefixes); while (!GlobalInitWorklist.empty()) { unsigned ValID = GlobalInitWorklist.back().second; @@ -988,7 +1091,7 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) GlobalInitWorklist.back().first->setInitializer(C); else - return Error("Global variable initializer is not a constant!"); + return Error(ExpectedConstant); } GlobalInitWorklist.pop_back(); } @@ -1001,11 +1104,25 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) AliasInitWorklist.back().first->setAliasee(C); else - return Error("Alias initializer is not a constant!"); + return Error(ExpectedConstant); } AliasInitWorklist.pop_back(); } - return false; + + while (!FunctionPrefixWorklist.empty()) { + unsigned ValID = FunctionPrefixWorklist.back().second; + if (ValID >= ValueList.size()) { + FunctionPrefixes.push_back(FunctionPrefixWorklist.back()); + } else { + if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) + FunctionPrefixWorklist.back().first->setPrefixData(C); + else + return Error(ExpectedConstant); + } + FunctionPrefixWorklist.pop_back(); + } + + return error_code::success(); } static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { @@ -1016,9 +1133,9 @@ static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { return APInt(TypeBits, Words); } -bool BitcodeReader::ParseConstants() { +error_code BitcodeReader::ParseConstants() { if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -1031,15 +1148,15 @@ bool BitcodeReader::ParseConstants() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed block record in AST file"); + return Error(MalformedBlock); case BitstreamEntry::EndBlock: if (NextCstNo != ValueList.size()) - return Error("Invalid constant reference!"); + return Error(InvalidConstantReference); // Once all the constants have been read, go through and resolve forward // references. ValueList.ResolveConstantForwardRefs(); - return false; + return error_code::success(); case BitstreamEntry::Record: // The interesting case. break; @@ -1056,9 +1173,9 @@ bool BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] if (Record.empty()) - return Error("Malformed CST_SETTYPE record"); + return Error(InvalidRecord); if (Record[0] >= TypeList.size()) - return Error("Invalid Type ID in CST_SETTYPE record"); + return Error(InvalidRecord); CurTy = TypeList[Record[0]]; continue; // Skip the ValueList manipulation. case bitc::CST_CODE_NULL: // NULL @@ -1066,12 +1183,12 @@ bool BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_INTEGER: // INTEGER: [intval] if (!CurTy->isIntegerTy() || Record.empty()) - return Error("Invalid CST_INTEGER record"); + return Error(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("Invalid WIDE_INTEGER record"); + return Error(InvalidRecord); APInt VInt = ReadWideAPInt(Record, cast<IntegerType>(CurTy)->getBitWidth()); @@ -1081,7 +1198,7 @@ bool BitcodeReader::ParseConstants() { } case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] if (Record.empty()) - return Error("Invalid FLOAT record"); + return Error(InvalidRecord); if (CurTy->isHalfTy()) V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, APInt(16, (uint16_t)Record[0]))); @@ -1111,7 +1228,7 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] if (Record.empty()) - return Error("Invalid CST_AGGREGATE record"); + return Error(InvalidRecord); unsigned Size = Record.size(); SmallVector<Constant*, 16> Elts; @@ -1139,7 +1256,7 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_STRING: // STRING: [values] case bitc::CST_CODE_CSTRING: { // CSTRING: [values] if (Record.empty()) - return Error("Invalid CST_STRING record"); + return Error(InvalidRecord); SmallString<16> Elts(Record.begin(), Record.end()); V = ConstantDataArray::getString(Context, Elts, @@ -1148,7 +1265,7 @@ bool BitcodeReader::ParseConstants() { } case bitc::CST_CODE_DATA: {// DATA: [n x value] if (Record.empty()) - return Error("Invalid CST_DATA record"); + return Error(InvalidRecord); Type *EltTy = cast<SequentialType>(CurTy)->getElementType(); unsigned Size = Record.size(); @@ -1193,13 +1310,14 @@ bool BitcodeReader::ParseConstants() { else V = ConstantDataArray::get(Context, Elts); } else { - return Error("Unknown element type in CE_DATA"); + return Error(InvalidTypeForValue); } break; } case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] - if (Record.size() < 3) return Error("Invalid CE_BINOP record"); + if (Record.size() < 3) + return Error(InvalidRecord); int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); if (Opc < 0) { V = UndefValue::get(CurTy); // Unknown binop. @@ -1229,25 +1347,30 @@ bool BitcodeReader::ParseConstants() { break; } case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] - if (Record.size() < 3) return Error("Invalid CE_CAST record"); + if (Record.size() < 3) + return Error(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("Invalid CE_CAST record"); + if (!OpTy) + return Error(InvalidRecord); Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); - V = ConstantExpr::getCast(Opc, Op, CurTy); + V = UpgradeBitCastExpr(Opc, Op, CurTy); + if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy); } break; } case bitc::CST_CODE_CE_INBOUNDS_GEP: case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] - if (Record.size() & 1) return Error("Invalid CE_GEP record"); + if (Record.size() & 1) + return Error(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("Invalid CE_GEP record"); + if (!ElTy) + return Error(InvalidRecord); Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); } ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); @@ -1256,19 +1379,31 @@ bool BitcodeReader::ParseConstants() { bitc::CST_CODE_CE_INBOUNDS_GEP); break; } - case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] - if (Record.size() < 3) return Error("Invalid CE_SELECT record"); - V = ConstantExpr::getSelect( - ValueList.getConstantFwdRef(Record[0], - Type::getInt1Ty(Context)), - ValueList.getConstantFwdRef(Record[1],CurTy), - ValueList.getConstantFwdRef(Record[2],CurTy)); + case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#] + if (Record.size() < 3) + return Error(InvalidRecord); + + Type *SelectorTy = Type::getInt1Ty(Context); + + // If CurTy is a vector of length n, then Record[0] must be a <n x i1> + // vector. Otherwise, it must be a single bit. + if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) + SelectorTy = VectorType::get(Type::getInt1Ty(Context), + VTy->getNumElements()); + + V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], + SelectorTy), + ValueList.getConstantFwdRef(Record[1],CurTy), + ValueList.getConstantFwdRef(Record[2],CurTy)); break; + } case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] - if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record"); + if (Record.size() < 3) + return Error(InvalidRecord); VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); - if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record"); + if (OpTy == 0) + return Error(InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); @@ -1278,7 +1413,7 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] VectorType *OpTy = dyn_cast<VectorType>(CurTy); if (Record.size() < 3 || OpTy == 0) - return Error("Invalid CE_INSERTELT record"); + return Error(InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy->getElementType()); @@ -1290,7 +1425,7 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] VectorType *OpTy = dyn_cast<VectorType>(CurTy); if (Record.size() < 3 || OpTy == 0) - return Error("Invalid CE_SHUFFLEVEC record"); + return Error(InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1304,7 +1439,7 @@ bool BitcodeReader::ParseConstants() { VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); if (Record.size() < 4 || RTy == 0 || OpTy == 0) - return Error("Invalid CE_SHUFVEC_EX record"); + return Error(InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1314,9 +1449,11 @@ bool BitcodeReader::ParseConstants() { break; } case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] - if (Record.size() < 4) return Error("Invalid CE_CMP record"); + if (Record.size() < 4) + return Error(InvalidRecord); Type *OpTy = getTypeByID(Record[0]); - if (OpTy == 0) return Error("Invalid CE_CMP record"); + if (OpTy == 0) + return Error(InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); @@ -1329,16 +1466,17 @@ bool BitcodeReader::ParseConstants() { // This maintains backward compatibility, pre-asm dialect keywords. // FIXME: Remove with the 4.0 release. case bitc::CST_CODE_INLINEASM_OLD: { - if (Record.size() < 2) return Error("Invalid INLINEASM record"); + if (Record.size() < 2) + return Error(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("Invalid INLINEASM record"); + return Error(InvalidRecord); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error("Invalid INLINEASM record"); + return Error(InvalidRecord); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1352,17 +1490,18 @@ bool BitcodeReader::ParseConstants() { // This version adds support for the asm dialect keywords (e.g., // inteldialect). case bitc::CST_CODE_INLINEASM: { - if (Record.size() < 2) return Error("Invalid INLINEASM record"); + if (Record.size() < 2) + return Error(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("Invalid INLINEASM record"); + return Error(InvalidRecord); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error("Invalid INLINEASM record"); + return Error(InvalidRecord); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1375,12 +1514,15 @@ bool BitcodeReader::ParseConstants() { break; } case bitc::CST_CODE_BLOCKADDRESS:{ - if (Record.size() < 3) return Error("Invalid CE_BLOCKADDRESS record"); + if (Record.size() < 3) + return Error(InvalidRecord); Type *FnTy = getTypeByID(Record[0]); - if (FnTy == 0) return Error("Invalid CE_BLOCKADDRESS record"); + if (FnTy == 0) + return Error(InvalidRecord); Function *Fn = dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); - if (Fn == 0) return Error("Invalid CE_BLOCKADDRESS record"); + if (Fn == 0) + return Error(InvalidRecord); // If the function is already parsed we can insert the block address right // away. @@ -1388,7 +1530,7 @@ bool BitcodeReader::ParseConstants() { Function::iterator BBI = Fn->begin(), BBE = Fn->end(); for (size_t I = 0, E = Record[2]; I != E; ++I) { if (BBI == BBE) - return Error("Invalid blockaddress block #"); + return Error(InvalidID); ++BBI; } V = BlockAddress::get(Fn, BBI); @@ -1411,9 +1553,9 @@ bool BitcodeReader::ParseConstants() { } } -bool BitcodeReader::ParseUseLists() { +error_code BitcodeReader::ParseUseLists() { if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -1424,9 +1566,9 @@ bool BitcodeReader::ParseUseLists() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed use list block"); + return Error(MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return error_code::success(); case BitstreamEntry::Record: // The interesting case. break; @@ -1440,7 +1582,7 @@ bool BitcodeReader::ParseUseLists() { case bitc::USELIST_CODE_ENTRY: { // USELIST_CODE_ENTRY: TBD. unsigned RecordLength = Record.size(); if (RecordLength < 1) - return Error ("Invalid UseList reader!"); + return Error(InvalidRecord); UseListRecords.push_back(Record); break; } @@ -1451,10 +1593,10 @@ bool BitcodeReader::ParseUseLists() { /// RememberAndSkipFunctionBody - When we see the block for a function body, /// remember where it is and then skip it. This lets us lazily deserialize the /// functions. -bool BitcodeReader::RememberAndSkipFunctionBody() { +error_code BitcodeReader::RememberAndSkipFunctionBody() { // Get the function we are talking about. if (FunctionsWithBodies.empty()) - return Error("Insufficient function protos"); + return Error(InsufficientFunctionProtos); Function *Fn = FunctionsWithBodies.back(); FunctionsWithBodies.pop_back(); @@ -1465,15 +1607,15 @@ bool BitcodeReader::RememberAndSkipFunctionBody() { // Skip over the function block for now. if (Stream.SkipBlock()) - return Error("Malformed block record"); - return false; + return Error(InvalidRecord); + return error_code::success(); } -bool BitcodeReader::GlobalCleanup() { +error_code BitcodeReader::GlobalCleanup() { // Patch the initializers for globals and aliases up. ResolveGlobalAndAliasInits(); if (!GlobalInits.empty() || !AliasInits.empty()) - return Error("Malformed global initializer set"); + return Error(MalformedGlobalInitializerSet); // Look for intrinsic functions which need to be upgraded at some point for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); @@ -1492,14 +1634,14 @@ bool BitcodeReader::GlobalCleanup() { // want lazy deserialization. std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); - return false; + return error_code::success(); } -bool BitcodeReader::ParseModule(bool Resume) { +error_code BitcodeReader::ParseModule(bool Resume) { if (Resume) Stream.JumpToBit(NextUnreadBit); else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); SmallVector<uint64_t, 64> Record; std::vector<std::string> SectionTable; @@ -1511,8 +1653,7 @@ bool BitcodeReader::ParseModule(bool Resume) { switch (Entry.Kind) { case BitstreamEntry::Error: - Error("malformed module block"); - return true; + return Error(MalformedBlock); case BitstreamEntry::EndBlock: return GlobalCleanup(); @@ -1520,49 +1661,51 @@ bool BitcodeReader::ParseModule(bool Resume) { switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error("Malformed block record"); + return Error(InvalidRecord); break; case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error("Malformed BlockInfoBlock"); + return Error(MalformedBlock); break; case bitc::PARAMATTR_BLOCK_ID: - if (ParseAttributeBlock()) - return true; + if (error_code EC = ParseAttributeBlock()) + return EC; break; case bitc::PARAMATTR_GROUP_BLOCK_ID: - if (ParseAttributeGroupBlock()) - return true; + if (error_code EC = ParseAttributeGroupBlock()) + return EC; break; case bitc::TYPE_BLOCK_ID_NEW: - if (ParseTypeTable()) - return true; + if (error_code EC = ParseTypeTable()) + return EC; break; case bitc::VALUE_SYMTAB_BLOCK_ID: - if (ParseValueSymbolTable()) - return true; + if (error_code EC = ParseValueSymbolTable()) + return EC; SeenValueSymbolTable = true; break; case bitc::CONSTANTS_BLOCK_ID: - if (ParseConstants() || ResolveGlobalAndAliasInits()) - return true; + if (error_code EC = ParseConstants()) + return EC; + if (error_code EC = ResolveGlobalAndAliasInits()) + return EC; break; case bitc::METADATA_BLOCK_ID: - if (ParseMetadata()) - return true; + if (error_code EC = ParseMetadata()) + return EC; break; case bitc::FUNCTION_BLOCK_ID: // If this is the first function body we've seen, reverse the // FunctionsWithBodies list. if (!SeenFirstFunctionBody) { std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); - if (GlobalCleanup()) - return true; + if (error_code EC = GlobalCleanup()) + return EC; SeenFirstFunctionBody = true; } - if (RememberAndSkipFunctionBody()) - return true; + if (error_code EC = RememberAndSkipFunctionBody()) + return EC; // For streaming bitcode, suspend parsing when we reach the function // bodies. Subsequent materialization calls will resume it when // necessary. For streaming, the function bodies must be at the end of @@ -1571,12 +1714,12 @@ bool BitcodeReader::ParseModule(bool Resume) { // just finish the parse now. if (LazyStreamer && SeenValueSymbolTable) { NextUnreadBit = Stream.GetCurrentBitNo(); - return false; + return error_code::success(); } break; case bitc::USELIST_BLOCK_ID: - if (ParseUseLists()) - return true; + if (error_code EC = ParseUseLists()) + return EC; break; } continue; @@ -1592,11 +1735,12 @@ bool BitcodeReader::ParseModule(bool Resume) { default: break; // Default behavior, ignore unknown content. case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] if (Record.size() < 1) - return Error("Malformed MODULE_CODE_VERSION"); + return Error(InvalidRecord); // Only version #0 and #1 are supported so far. unsigned module_version = Record[0]; switch (module_version) { - default: return Error("Unknown bitstream version!"); + default: + return Error(InvalidValue); case 0: UseRelativeIDs = false; break; @@ -1609,21 +1753,21 @@ bool BitcodeReader::ParseModule(bool Resume) { case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_TRIPLE record"); + return Error(InvalidRecord); TheModule->setTargetTriple(S); break; } case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_DATALAYOUT record"); + return Error(InvalidRecord); TheModule->setDataLayout(S); break; } case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_ASM record"); + return Error(InvalidRecord); TheModule->setModuleInlineAsm(S); break; } @@ -1631,21 +1775,21 @@ bool BitcodeReader::ParseModule(bool Resume) { // FIXME: Remove in 4.0. std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_DEPLIB record"); + return Error(InvalidRecord); // Ignore value. break; } case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_SECTIONNAME record"); + return Error(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("Invalid MODULE_CODE_GCNAME record"); + return Error(InvalidRecord); GCTable.push_back(S); break; } @@ -1654,11 +1798,12 @@ bool BitcodeReader::ParseModule(bool Resume) { // unnamed_addr] case bitc::MODULE_CODE_GLOBALVAR: { if (Record.size() < 6) - return Error("Invalid MODULE_CODE_GLOBALVAR record"); + return Error(InvalidRecord); Type *Ty = getTypeByID(Record[0]); - if (!Ty) return Error("Invalid MODULE_CODE_GLOBALVAR record"); + if (!Ty) + return Error(InvalidRecord); if (!Ty->isPointerTy()) - return Error("Global not a pointer type!"); + return Error(InvalidTypeForValue); unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); Ty = cast<PointerType>(Ty)->getElementType(); @@ -1668,7 +1813,7 @@ bool BitcodeReader::ParseModule(bool Resume) { std::string Section; if (Record[5]) { if (Record[5]-1 >= SectionTable.size()) - return Error("Invalid section ID"); + return Error(InvalidID); Section = SectionTable[Record[5]-1]; } GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; @@ -1707,15 +1852,16 @@ bool BitcodeReader::ParseModule(bool Resume) { // alignment, section, visibility, gc, unnamed_addr] case bitc::MODULE_CODE_FUNCTION: { if (Record.size() < 8) - return Error("Invalid MODULE_CODE_FUNCTION record"); + return Error(InvalidRecord); Type *Ty = getTypeByID(Record[0]); - if (!Ty) return Error("Invalid MODULE_CODE_FUNCTION record"); + if (!Ty) + return Error(InvalidRecord); if (!Ty->isPointerTy()) - return Error("Function not a pointer type!"); + return Error(InvalidTypeForValue); FunctionType *FTy = dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); if (!FTy) - return Error("Function not a pointer to function type!"); + return Error(InvalidTypeForValue); Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, "", TheModule); @@ -1728,19 +1874,21 @@ bool BitcodeReader::ParseModule(bool Resume) { Func->setAlignment((1 << Record[5]) >> 1); if (Record[6]) { if (Record[6]-1 >= SectionTable.size()) - return Error("Invalid section ID"); + return Error(InvalidID); Func->setSection(SectionTable[Record[6]-1]); } Func->setVisibility(GetDecodedVisibility(Record[7])); if (Record.size() > 8 && Record[8]) { if (Record[8]-1 > GCTable.size()) - return Error("Invalid GC ID"); + return Error(InvalidID); Func->setGC(GCTable[Record[8]-1].c_str()); } bool UnnamedAddr = false; if (Record.size() > 9) UnnamedAddr = Record[9]; Func->setUnnamedAddr(UnnamedAddr); + if (Record.size() > 10 && Record[10] != 0) + FunctionPrefixes.push_back(std::make_pair(Func, Record[10]-1)); ValueList.push_back(Func); // If this is a function with a body, remember the prototype we are @@ -1755,11 +1903,12 @@ bool BitcodeReader::ParseModule(bool Resume) { // ALIAS: [alias type, aliasee val#, linkage, visibility] case bitc::MODULE_CODE_ALIAS: { if (Record.size() < 3) - return Error("Invalid MODULE_ALIAS record"); + return Error(InvalidRecord); Type *Ty = getTypeByID(Record[0]); - if (!Ty) return Error("Invalid MODULE_ALIAS record"); + if (!Ty) + return Error(InvalidRecord); if (!Ty->isPointerTy()) - return Error("Function not a pointer type!"); + return Error(InvalidTypeForValue); GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), "", 0, TheModule); @@ -1774,7 +1923,7 @@ bool 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("Invalid MODULE_PURGEVALS record"); + return Error(InvalidRecord); ValueList.shrinkTo(Record[0]); break; } @@ -1782,10 +1931,11 @@ bool BitcodeReader::ParseModule(bool Resume) { } } -bool BitcodeReader::ParseBitcodeInto(Module *M) { +error_code BitcodeReader::ParseBitcodeInto(Module *M) { TheModule = 0; - if (InitStream()) return true; + if (error_code EC = InitStream()) + return EC; // Sniff for the signature. if (Stream.Read(8) != 'B' || @@ -1794,42 +1944,42 @@ bool BitcodeReader::ParseBitcodeInto(Module *M) { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error("Invalid bitcode signature"); + return Error(InvalidBitcodeSignature); // We expect a number of well-defined blocks, though we don't necessarily // need to understand them all. while (1) { if (Stream.AtEndOfStream()) - return false; + return error_code::success(); BitstreamEntry Entry = Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); switch (Entry.Kind) { case BitstreamEntry::Error: - Error("malformed module file"); - return true; + return Error(MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return error_code::success(); case BitstreamEntry::SubBlock: switch (Entry.ID) { case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error("Malformed BlockInfoBlock"); + return Error(MalformedBlock); break; case bitc::MODULE_BLOCK_ID: // Reject multiple MODULE_BLOCK's in a single bitstream. if (TheModule) - return Error("Multiple MODULE_BLOCKs in same stream"); + return Error(InvalidMultipleBlocks); TheModule = M; - if (ParseModule(false)) - return true; - if (LazyStreamer) return false; + if (error_code EC = ParseModule(false)) + return EC; + if (LazyStreamer) + return error_code::success(); break; default: if (Stream.SkipBlock()) - return Error("Malformed block record"); + return Error(InvalidRecord); break; } continue; @@ -1842,16 +1992,16 @@ bool BitcodeReader::ParseBitcodeInto(Module *M) { if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && Stream.AtEndOfStream()) - return false; + return error_code::success(); - return Error("Invalid record at top-level"); + return Error(InvalidRecord); } } } -bool BitcodeReader::ParseModuleTriple(std::string &Triple) { +error_code BitcodeReader::ParseModuleTriple(std::string &Triple) { if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -1862,9 +2012,9 @@ bool BitcodeReader::ParseModuleTriple(std::string &Triple) { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed module block"); + return Error(MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return error_code::success(); case BitstreamEntry::Record: // The interesting case. break; @@ -1876,7 +2026,7 @@ bool BitcodeReader::ParseModuleTriple(std::string &Triple) { case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_TRIPLE record"); + return Error(InvalidRecord); Triple = S; break; } @@ -1885,8 +2035,9 @@ bool BitcodeReader::ParseModuleTriple(std::string &Triple) { } } -bool BitcodeReader::ParseTriple(std::string &Triple) { - if (InitStream()) return true; +error_code BitcodeReader::ParseTriple(std::string &Triple) { + if (error_code EC = InitStream()) + return EC; // Sniff for the signature. if (Stream.Read(8) != 'B' || @@ -1895,7 +2046,7 @@ bool BitcodeReader::ParseTriple(std::string &Triple) { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error("Invalid bitcode signature"); + return Error(InvalidBitcodeSignature); // We expect a number of well-defined blocks, though we don't necessarily // need to understand them all. @@ -1904,20 +2055,17 @@ bool BitcodeReader::ParseTriple(std::string &Triple) { switch (Entry.Kind) { case BitstreamEntry::Error: - Error("malformed module file"); - return true; + return Error(MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return error_code::success(); case BitstreamEntry::SubBlock: if (Entry.ID == bitc::MODULE_BLOCK_ID) return ParseModuleTriple(Triple); // Ignore other sub-blocks. - if (Stream.SkipBlock()) { - Error("malformed block record in AST file"); - return true; - } + if (Stream.SkipBlock()) + return Error(MalformedBlock); continue; case BitstreamEntry::Record: @@ -1928,9 +2076,9 @@ bool BitcodeReader::ParseTriple(std::string &Triple) { } /// ParseMetadataAttachment - Parse metadata attachments. -bool BitcodeReader::ParseMetadataAttachment() { +error_code BitcodeReader::ParseMetadataAttachment() { if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); SmallVector<uint64_t, 64> Record; while (1) { @@ -1939,9 +2087,9 @@ bool BitcodeReader::ParseMetadataAttachment() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed metadata block"); + return Error(MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return error_code::success(); case BitstreamEntry::Record: // The interesting case. break; @@ -1955,16 +2103,18 @@ bool BitcodeReader::ParseMetadataAttachment() { case bitc::METADATA_ATTACHMENT: { unsigned RecordLength = Record.size(); if (Record.empty() || (RecordLength - 1) % 2 == 1) - return Error ("Invalid METADATA_ATTACHMENT reader!"); + return Error(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("Invalid metadata kind ID"); + return Error(InvalidID); Value *Node = MDValueList.getValueFwdRef(Record[i+1]); Inst->setMetadata(I->second, cast<MDNode>(Node)); + if (I->second == LLVMContext::MD_tbaa) + InstsWithTBAATag.push_back(Inst); } break; } @@ -1973,9 +2123,9 @@ bool BitcodeReader::ParseMetadataAttachment() { } /// ParseFunctionBody - Lazily parse the specified function body block. -bool BitcodeReader::ParseFunctionBody(Function *F) { +error_code BitcodeReader::ParseFunctionBody(Function *F) { if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); InstructionList.clear(); unsigned ModuleValueListSize = ValueList.size(); @@ -1998,7 +2148,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error("Bitcode error in function block"); + return Error(MalformedBlock); case BitstreamEntry::EndBlock: goto OutOfRecordLoop; @@ -2006,20 +2156,24 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error("Malformed block record"); + return Error(InvalidRecord); break; case bitc::CONSTANTS_BLOCK_ID: - if (ParseConstants()) return true; + if (error_code EC = ParseConstants()) + return EC; NextValueNo = ValueList.size(); break; case bitc::VALUE_SYMTAB_BLOCK_ID: - if (ParseValueSymbolTable()) return true; + if (error_code EC = ParseValueSymbolTable()) + return EC; break; case bitc::METADATA_ATTACHMENT_ID: - if (ParseMetadataAttachment()) return true; + if (error_code EC = ParseMetadataAttachment()) + return EC; break; case bitc::METADATA_BLOCK_ID: - if (ParseMetadata()) return true; + if (error_code EC = ParseMetadata()) + return EC; break; } continue; @@ -2035,10 +2189,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned BitCode = Stream.readRecord(Entry.ID, Record); switch (BitCode) { default: // Default behavior: reject - return Error("Unknown instruction"); + return Error(InvalidValue); case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] if (Record.size() < 1 || Record[0] == 0) - return Error("Invalid DECLAREBLOCKS record"); + return Error(InvalidRecord); // Create all the basic blocks for the function. FunctionBBs.resize(Record[0]); for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) @@ -2058,7 +2212,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { !FunctionBBs[CurBBNo-1]->empty()) I = &FunctionBBs[CurBBNo-1]->back(); - if (I == 0) return Error("Invalid DEBUG_LOC_AGAIN record"); + if (I == 0) + return Error(InvalidRecord); I->setDebugLoc(LastLoc); I = 0; continue; @@ -2071,7 +2226,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { !FunctionBBs[CurBBNo-1]->empty()) I = &FunctionBBs[CurBBNo-1]->back(); if (I == 0 || Record.size() < 4) - return Error("Invalid FUNC_CODE_DEBUG_LOC record"); + return Error(InvalidRecord); unsigned Line = Record[0], Col = Record[1]; unsigned ScopeID = Record[2], IAID = Record[3]; @@ -2091,10 +2246,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || OpNum+1 > Record.size()) - return Error("Invalid BINOP record"); + return Error(InvalidRecord); int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); - if (Opc == -1) return Error("Invalid BINOP record"); + if (Opc == -1) + return Error(InvalidRecord); I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); InstructionList.push_back(I); if (OpNum < Record.size()) { @@ -2136,13 +2292,21 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error("Invalid CAST record"); + return Error(InvalidRecord); Type *ResTy = getTypeByID(Record[OpNum]); int Opc = GetDecodedCastOpcode(Record[OpNum+1]); if (Opc == -1 || ResTy == 0) - return Error("Invalid CAST record"); - I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); + return Error(InvalidRecord); + Instruction *Temp = 0; + if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) { + if (Temp) { + InstructionList.push_back(Temp); + CurBB->getInstList().push_back(Temp); + } + } else { + I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); + } InstructionList.push_back(I); break; } @@ -2151,13 +2315,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *BasePtr; if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) - return Error("Invalid GEP record"); + return Error(InvalidRecord); SmallVector<Value*, 16> GEPIdx; while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error("Invalid GEP record"); + return Error(InvalidRecord); GEPIdx.push_back(Op); } @@ -2173,14 +2337,14 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error("Invalid EXTRACTVAL record"); + return Error(InvalidRecord); SmallVector<unsigned, 4> EXTRACTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error("Invalid EXTRACTVAL index"); + return Error(InvalidValue); EXTRACTVALIdx.push_back((unsigned)Index); } @@ -2194,17 +2358,17 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error("Invalid INSERTVAL record"); + return Error(InvalidRecord); Value *Val; if (getValueTypePair(Record, OpNum, NextValueNo, Val)) - return Error("Invalid INSERTVAL record"); + return Error(InvalidRecord); SmallVector<unsigned, 4> INSERTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error("Invalid INSERTVAL index"); + return Error(InvalidValue); INSERTVALIdx.push_back((unsigned)Index); } @@ -2221,7 +2385,7 @@ bool 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("Invalid SELECT record"); + return Error(InvalidRecord); I = SelectInst::Create(Cond, TrueVal, FalseVal); InstructionList.push_back(I); @@ -2236,18 +2400,18 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || getValueTypePair(Record, OpNum, NextValueNo, Cond)) - return Error("Invalid SELECT record"); + return Error(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("Invalid SELECT condition type"); + return Error(InvalidTypeForValue); } else { // expect i1 if (Cond->getType() != Type::getInt1Ty(Context)) - return Error("Invalid SELECT condition type"); + return Error(InvalidTypeForValue); } I = SelectInst::Create(Cond, TrueVal, FalseVal); @@ -2260,7 +2424,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Vec, *Idx; if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx)) - return Error("Invalid EXTRACTELT record"); + return Error(InvalidRecord); I = ExtractElementInst::Create(Vec, Idx); InstructionList.push_back(I); break; @@ -2273,7 +2437,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<VectorType>(Vec->getType())->getElementType(), Elt) || popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx)) - return Error("Invalid INSERTELT record"); + return Error(InvalidRecord); I = InsertElementInst::Create(Vec, Elt, Idx); InstructionList.push_back(I); break; @@ -2284,10 +2448,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Vec1, *Vec2, *Mask; if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2)) - return Error("Invalid SHUFFLEVEC record"); + return Error(InvalidRecord); if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) - return Error("Invalid SHUFFLEVEC record"); + return Error(InvalidRecord); I = new ShuffleVectorInst(Vec1, Vec2, Mask); InstructionList.push_back(I); break; @@ -2305,7 +2469,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || OpNum+1 != Record.size()) - return Error("Invalid CMP record"); + return Error(InvalidRecord); if (LHS->getType()->isFPOrFPVectorTy()) I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); @@ -2327,9 +2491,9 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Op = NULL; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error("Invalid RET record"); + return Error(InvalidRecord); if (OpNum != Record.size()) - return Error("Invalid RET record"); + return Error(InvalidRecord); I = ReturnInst::Create(Context, Op); InstructionList.push_back(I); @@ -2337,10 +2501,10 @@ bool 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("Invalid BR record"); + return Error(InvalidRecord); BasicBlock *TrueDest = getBasicBlock(Record[0]); if (TrueDest == 0) - return Error("Invalid BR record"); + return Error(InvalidRecord); if (Record.size() == 1) { I = BranchInst::Create(TrueDest); @@ -2351,7 +2515,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Cond = getValue(Record, 2, NextValueNo, Type::getInt1Ty(Context)); if (FalseDest == 0 || Cond == 0) - return Error("Invalid BR record"); + return Error(InvalidRecord); I = BranchInst::Create(TrueDest, FalseDest, Cond); InstructionList.push_back(I); } @@ -2360,7 +2524,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] // Check magic if ((Record[0] >> 16) == SWITCH_INST_MAGIC) { - // New SwitchInst format with case ranges. + // "New" SwitchInst format with case ranges. The changes to write this + // format were reverted but we still recognize bitcode that uses it. + // Hopefully someday we will have support for case ranges and can use + // this format again. Type *OpTy = getTypeByID(Record[1]); unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth(); @@ -2368,7 +2535,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Cond = getValue(Record, 2, NextValueNo, OpTy); BasicBlock *Default = getBasicBlock(Record[3]); if (OpTy == 0 || Cond == 0 || Default == 0) - return Error("Invalid SWITCH record"); + return Error(InvalidRecord); unsigned NumCases = Record[4]; @@ -2377,7 +2544,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned CurIdx = 5; for (unsigned i = 0; i != NumCases; ++i) { - IntegersSubsetToBB CaseBuilder; + SmallVector<ConstantInt*, 1> CaseVals; unsigned NumItems = Record[CurIdx++]; for (unsigned ci = 0; ci != NumItems; ++ci) { bool isSingleNumber = Record[CurIdx++]; @@ -2397,20 +2564,22 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { APInt High = ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth); - - CaseBuilder.add(IntItem::fromType(OpTy, Low), - IntItem::fromType(OpTy, High)); CurIdx += ActiveWords; + + // FIXME: It is not clear whether values in the range should be + // compared as signed or unsigned values. The partially + // implemented changes that used this format in the past used + // unsigned comparisons. + for ( ; Low.ule(High); ++Low) + CaseVals.push_back(ConstantInt::get(Context, Low)); } else - CaseBuilder.add(IntItem::fromType(OpTy, Low)); + CaseVals.push_back(ConstantInt::get(Context, Low)); } BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]); - IntegersSubset Case = CaseBuilder.getCase(); - SI->addCase(Case, DestBB); + for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(), + cve = CaseVals.end(); cvi != cve; ++cvi) + SI->addCase(*cvi, DestBB); } - uint16_t Hash = SI->hash(); - if (Hash != (Record[0] & 0xFFFF)) - return Error("Invalid SWITCH record"); I = SI; break; } @@ -2418,12 +2587,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // Old SwitchInst format without case ranges. if (Record.size() < 3 || (Record.size() & 1) == 0) - return Error("Invalid SWITCH record"); + return Error(InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Cond = getValue(Record, 1, NextValueNo, OpTy); BasicBlock *Default = getBasicBlock(Record[2]); if (OpTy == 0 || Cond == 0 || Default == 0) - return Error("Invalid SWITCH record"); + return Error(InvalidRecord); unsigned NumCases = (Record.size()-3)/2; SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); InstructionList.push_back(SI); @@ -2433,7 +2602,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); if (CaseVal == 0 || DestBB == 0) { delete SI; - return Error("Invalid SWITCH record!"); + return Error(InvalidRecord); } SI->addCase(CaseVal, DestBB); } @@ -2442,11 +2611,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] if (Record.size() < 2) - return Error("Invalid INDIRECTBR record"); + return Error(InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Address = getValue(Record, 1, NextValueNo, OpTy); if (OpTy == 0 || Address == 0) - return Error("Invalid INDIRECTBR record"); + return Error(InvalidRecord); unsigned NumDests = Record.size()-2; IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); InstructionList.push_back(IBI); @@ -2455,7 +2624,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { IBI->addDestination(DestBB); } else { delete IBI; - return Error("Invalid INDIRECTBR record!"); + return Error(InvalidRecord); } } I = IBI; @@ -2464,7 +2633,8 @@ bool 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("Invalid INVOKE record"); + if (Record.size() < 4) + return Error(InvalidRecord); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; BasicBlock *NormalBB = getBasicBlock(Record[2]); @@ -2473,7 +2643,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 4; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error("Invalid INVOKE record"); + return Error(InvalidRecord); PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); FunctionType *FTy = !CalleeTy ? 0 : @@ -2482,24 +2652,25 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // Check that the right number of fixed parameters are here. if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || Record.size() < OpNum+FTy->getNumParams()) - return Error("Invalid INVOKE record"); + return Error(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() == 0) return Error("Invalid INVOKE record"); + if (Ops.back() == 0) + return Error(InvalidRecord); } if (!FTy->isVarArg()) { if (Record.size() != OpNum) - return Error("Invalid INVOKE record"); + return Error(InvalidRecord); } else { // Read type/value pairs for varargs params. while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error("Invalid INVOKE record"); + return Error(InvalidRecord); Ops.push_back(Op); } } @@ -2515,7 +2686,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned Idx = 0; Value *Val = 0; if (getValueTypePair(Record, Idx, NextValueNo, Val)) - return Error("Invalid RESUME record"); + return Error(InvalidRecord); I = ResumeInst::Create(Val); InstructionList.push_back(I); break; @@ -2526,9 +2697,10 @@ bool 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("Invalid PHI record"); + return Error(InvalidRecord); Type *Ty = getTypeByID(Record[0]); - if (!Ty) return Error("Invalid PHI record"); + if (!Ty) + return Error(InvalidRecord); PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); InstructionList.push_back(PN); @@ -2543,7 +2715,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { else V = getValue(Record, 1+i, NextValueNo, Ty); BasicBlock *BB = getBasicBlock(Record[2+i]); - if (!V || !BB) return Error("Invalid PHI record"); + if (!V || !BB) + return Error(InvalidRecord); PN->addIncoming(V, BB); } I = PN; @@ -2554,12 +2727,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] unsigned Idx = 0; if (Record.size() < 4) - return Error("Invalid LANDINGPAD record"); + return Error(InvalidRecord); Type *Ty = getTypeByID(Record[Idx++]); - if (!Ty) return Error("Invalid LANDINGPAD record"); + if (!Ty) + return Error(InvalidRecord); Value *PersFn = 0; if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) - return Error("Invalid LANDINGPAD record"); + return Error(InvalidRecord); bool IsCleanup = !!Record[Idx++]; unsigned NumClauses = Record[Idx++]; @@ -2572,7 +2746,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, Idx, NextValueNo, Val)) { delete LP; - return Error("Invalid LANDINGPAD record"); + return Error(InvalidRecord); } assert((CT != LandingPadInst::Catch || @@ -2591,13 +2765,14 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] if (Record.size() != 4) - return Error("Invalid ALLOCA record"); + return Error(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]; - if (!Ty || !Size) return Error("Invalid ALLOCA record"); + if (!Ty || !Size) + return Error(InvalidRecord); I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); InstructionList.push_back(I); break; @@ -2607,7 +2782,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error("Invalid LOAD record"); + return Error(InvalidRecord); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -2619,15 +2794,15 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+4 != Record.size()) - return Error("Invalid LOADATOMIC record"); + return Error(InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Release || Ordering == AcquireRelease) - return Error("Invalid LOADATOMIC record"); + return Error(InvalidRecord); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error("Invalid LOADATOMIC record"); + return Error(InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, @@ -2642,7 +2817,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+2 != Record.size()) - return Error("Invalid STORE record"); + return Error(InvalidRecord); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -2656,15 +2831,15 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error("Invalid STOREATOMIC record"); + return Error(InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Acquire || Ordering == AcquireRelease) - return Error("Invalid STOREATOMIC record"); + return Error(InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error("Invalid STOREATOMIC record"); + return Error(InvalidRecord); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, Ordering, SynchScope); @@ -2681,10 +2856,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), New) || OpNum+3 != Record.size()) - return Error("Invalid CMPXCHG record"); + return Error(InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]); if (Ordering == NotAtomic || Ordering == Unordered) - return Error("Invalid CMPXCHG record"); + return Error(InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, SynchScope); cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]); @@ -2699,14 +2874,14 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error("Invalid ATOMICRMW record"); + return Error(InvalidRecord); AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); if (Operation < AtomicRMWInst::FIRST_BINOP || Operation > AtomicRMWInst::LAST_BINOP) - return Error("Invalid ATOMICRMW record"); + return Error(InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Unordered) - return Error("Invalid ATOMICRMW record"); + return Error(InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); @@ -2715,11 +2890,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] if (2 != Record.size()) - return Error("Invalid FENCE record"); + return Error(InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); if (Ordering == NotAtomic || Ordering == Unordered || Ordering == Monotonic) - return Error("Invalid FENCE record"); + return Error(InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); I = new FenceInst(Context, Ordering, SynchScope); InstructionList.push_back(I); @@ -2728,7 +2903,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_CALL: { // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] if (Record.size() < 3) - return Error("Invalid CALL record"); + return Error(InvalidRecord); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; @@ -2736,13 +2911,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 2; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error("Invalid CALL record"); + return Error(InvalidRecord); PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); FunctionType *FTy = 0; if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); if (!FTy || Record.size() < FTy->getNumParams()+OpNum) - return Error("Invalid CALL record"); + return Error(InvalidRecord); SmallVector<Value*, 16> Args; // Read the fixed params. @@ -2752,18 +2927,19 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { else Args.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i))); - if (Args.back() == 0) return Error("Invalid CALL record"); + if (Args.back() == 0) + return Error(InvalidRecord); } // Read type/value pairs for varargs params. if (!FTy->isVarArg()) { if (OpNum != Record.size()) - return Error("Invalid CALL record"); + return Error(InvalidRecord); } else { while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error("Invalid CALL record"); + return Error(InvalidRecord); Args.push_back(Op); } } @@ -2778,12 +2954,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] if (Record.size() < 3) - return Error("Invalid VAARG record"); + return Error(InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Op = getValue(Record, 1, NextValueNo, OpTy); Type *ResTy = getTypeByID(Record[2]); if (!OpTy || !Op || !ResTy) - return Error("Invalid VAARG record"); + return Error(InvalidRecord); I = new VAArgInst(Op, ResTy); InstructionList.push_back(I); break; @@ -2794,7 +2970,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // this file. if (CurBB == 0) { delete I; - return Error("Invalid instruction with no BB"); + return Error(InvalidInstructionWithNoBB); } CurBB->getInstList().push_back(I); @@ -2821,7 +2997,7 @@ OutOfRecordLoop: delete A; } } - return Error("Never resolved value found in function!"); + return Error(NeverResolvedValueFoundInFunction); } } @@ -2837,7 +3013,7 @@ OutOfRecordLoop: for (unsigned i = 0, e = RefList.size(); i != e; ++i) { unsigned BlockIdx = RefList[i].first; if (BlockIdx >= FunctionBBs.size()) - return Error("Invalid blockaddress block #"); + return Error(InvalidID); GlobalVariable *FwdRef = RefList[i].second; FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); @@ -2851,20 +3027,21 @@ OutOfRecordLoop: ValueList.shrinkTo(ModuleValueListSize); MDValueList.shrinkTo(ModuleMDValueListSize); std::vector<BasicBlock*>().swap(FunctionBBs); - return false; + return error_code::success(); } -/// FindFunctionInStream - Find the function body in the bitcode stream -bool BitcodeReader::FindFunctionInStream(Function *F, +/// Find the function body in the bitcode stream +error_code BitcodeReader::FindFunctionInStream(Function *F, DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator) { while (DeferredFunctionInfoIterator->second == 0) { if (Stream.AtEndOfStream()) - return Error("Could not find Function in stream"); + return Error(CouldNotFindFunctionInStream); // ParseModule will parse the next body in the stream and set its // position in the DeferredFunctionInfo map. - if (ParseModule(true)) return true; + if (error_code EC = ParseModule(true)) + return EC; } - return false; + return error_code::success(); } //===----------------------------------------------------------------------===// @@ -2880,25 +3057,25 @@ bool BitcodeReader::isMaterializable(const GlobalValue *GV) const { return false; } -bool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) { +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()) return false; + if (!F || !F->isMaterializable()) + return error_code::success(); DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); // If its position is recorded as 0, its body is somewhere in the stream // but we haven't seen it yet. - if (DFII->second == 0) - if (LazyStreamer && FindFunctionInStream(F, DFII)) return true; + if (DFII->second == 0 && LazyStreamer) + if (error_code EC = FindFunctionInStream(F, DFII)) + return EC; // Move the bit stream to the saved position of the deferred function body. Stream.JumpToBit(DFII->second); - if (ParseFunctionBody(F)) { - if (ErrInfo) *ErrInfo = ErrorString; - return true; - } + if (error_code EC = ParseFunctionBody(F)) + return EC; // Upgrade any old intrinsic calls in the function. for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), @@ -2912,7 +3089,7 @@ bool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) { } } - return false; + return error_code::success(); } bool BitcodeReader::isDematerializable(const GlobalValue *GV) const { @@ -2935,17 +3112,18 @@ void BitcodeReader::Dematerialize(GlobalValue *GV) { } -bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { +error_code BitcodeReader::MaterializeModule(Module *M) { assert(M == TheModule && "Can only Materialize the Module this BitcodeReader is attached to."); // 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() && - Materialize(F, ErrInfo)) - return true; - + F != E; ++F) { + if (F->isMaterializable()) { + if (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 // of the bits in the module have been read. @@ -2971,38 +3149,43 @@ bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { } std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); - return false; + for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++) + UpgradeInstWithTBAATag(InstsWithTBAATag[I]); + + UpgradeDebugInfo(*M); + return error_code::success(); } -bool BitcodeReader::InitStream() { - if (LazyStreamer) return InitLazyStream(); +error_code BitcodeReader::InitStream() { + if (LazyStreamer) + return InitLazyStream(); return InitStreamFromBuffer(); } -bool BitcodeReader::InitStreamFromBuffer() { +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("Invalid bitcode signature"); + return Error(InvalidBitcodeSignature); else - return Error("Bitcode stream should be a multiple of 4 bytes in length"); + return Error(BitcodeStreamInvalidSize); } // 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("Invalid bitcode wrapper header"); + return Error(InvalidBitcodeWrapperHeader); StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); Stream.init(*StreamFile); - return false; + return error_code::success(); } -bool BitcodeReader::InitLazyStream() { +error_code BitcodeReader::InitLazyStream() { // Check and strip off the bitcode wrapper; BitstreamReader expects never to // see it. StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); @@ -3010,11 +3193,11 @@ bool BitcodeReader::InitLazyStream() { Stream.init(*StreamFile); unsigned char buf[16]; - if (Bytes->readBytes(0, 16, buf, NULL) == -1) - return Error("Bitcode stream must be at least 16 bytes in length"); + if (Bytes->readBytes(0, 16, buf) == -1) + return Error(BitcodeStreamInvalidSize); if (!isBitcode(buf, buf + 16)) - return Error("Invalid bitcode signature"); + return Error(InvalidBitcodeSignature); if (isBitcodeWrapper(buf, buf + 4)) { const unsigned char *bitcodeStart = buf; @@ -3023,7 +3206,64 @@ bool BitcodeReader::InitLazyStream() { Bytes->dropLeadingBytes(bitcodeStart - buf); Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); } - return false; + return error_code::success(); +} + +namespace { +class BitcodeErrorCategoryType : public _do_message { + const char *name() const LLVM_OVERRIDE { + return "llvm.bitcode"; + } + std::string message(int IE) const LLVM_OVERRIDE { + BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE); + switch (E) { + case BitcodeReader::BitcodeStreamInvalidSize: + return "Bitcode stream length should be >= 16 bytes and a multiple of 4"; + case BitcodeReader::ConflictingMETADATA_KINDRecords: + return "Conflicting METADATA_KIND records"; + case BitcodeReader::CouldNotFindFunctionInStream: + return "Could not find function in stream"; + case BitcodeReader::ExpectedConstant: + return "Expected a constant"; + case BitcodeReader::InsufficientFunctionProtos: + return "Insufficient function protos"; + case BitcodeReader::InvalidBitcodeSignature: + return "Invalid bitcode signature"; + case BitcodeReader::InvalidBitcodeWrapperHeader: + return "Invalid bitcode wrapper header"; + case BitcodeReader::InvalidConstantReference: + return "Invalid ronstant reference"; + case BitcodeReader::InvalidID: + return "Invalid ID"; + case BitcodeReader::InvalidInstructionWithNoBB: + return "Invalid instruction with no BB"; + case BitcodeReader::InvalidRecord: + return "Invalid record"; + case BitcodeReader::InvalidTypeForValue: + return "Invalid type for value"; + case BitcodeReader::InvalidTYPETable: + return "Invalid TYPE table"; + case BitcodeReader::InvalidType: + return "Invalid type"; + case BitcodeReader::MalformedBlock: + return "Malformed block"; + case BitcodeReader::MalformedGlobalInitializerSet: + return "Malformed global initializer set"; + case BitcodeReader::InvalidMultipleBlocks: + return "Invalid multiple blocks"; + case BitcodeReader::NeverResolvedValueFoundInFunction: + return "Never resolved value found in function"; + case BitcodeReader::InvalidValue: + return "Invalid value"; + } + llvm_unreachable("Unknown error type!"); + } +}; +} + +const error_category &BitcodeReader::BitcodeErrorCategory() { + static BitcodeErrorCategoryType O; + return O; } //===----------------------------------------------------------------------===// @@ -3038,9 +3278,9 @@ Module *llvm::getLazyBitcodeModule(MemoryBuffer *Buffer, Module *M = new Module(Buffer->getBufferIdentifier(), Context); BitcodeReader *R = new BitcodeReader(Buffer, Context); M->setMaterializer(R); - if (R->ParseBitcodeInto(M)) { + if (error_code EC = R->ParseBitcodeInto(M)) { if (ErrMsg) - *ErrMsg = R->getErrorString(); + *ErrMsg = EC.message(); delete M; // Also deletes R. return 0; @@ -3061,9 +3301,9 @@ Module *llvm::getStreamedBitcodeModule(const std::string &name, Module *M = new Module(name, Context); BitcodeReader *R = new BitcodeReader(streamer, Context); M->setMaterializer(R); - if (R->ParseBitcodeInto(M)) { + if (error_code EC = R->ParseBitcodeInto(M)) { if (ErrMsg) - *ErrMsg = R->getErrorString(); + *ErrMsg = EC.message(); delete M; // Also deletes R. return 0; } @@ -3102,9 +3342,9 @@ std::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer, R->setBufferOwned(false); std::string Triple(""); - if (R->ParseTriple(Triple)) + if (error_code EC = R->ParseTriple(Triple)) if (ErrMsg) - *ErrMsg = R->getErrorString(); + *ErrMsg = EC.message(); delete R; return Triple; diff --git a/contrib/llvm/lib/Bitcode/Reader/BitcodeReader.h b/contrib/llvm/lib/Bitcode/Reader/BitcodeReader.h index 28674eb..c5d345b 100644 --- a/contrib/llvm/lib/Bitcode/Reader/BitcodeReader.h +++ b/contrib/llvm/lib/Bitcode/Reader/BitcodeReader.h @@ -21,6 +21,7 @@ #include "llvm/IR/Attributes.h" #include "llvm/IR/OperandTraits.h" #include "llvm/IR/Type.h" +#include "llvm/Support/system_error.h" #include "llvm/Support/ValueHandle.h" #include <vector> @@ -132,8 +133,6 @@ class BitcodeReader : public GVMaterializer { uint64_t NextUnreadBit; bool SeenValueSymbolTable; - const char *ErrorString; - std::vector<Type*> TypeList; BitcodeReaderValueList ValueList; BitcodeReaderMDValueList MDValueList; @@ -142,6 +141,9 @@ class BitcodeReader : public GVMaterializer { std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits; std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits; + std::vector<std::pair<Function*, unsigned> > FunctionPrefixes; + + SmallVector<Instruction*, 64> InstsWithTBAATag; /// MAttributes - The set of attributes by index. Index zero in the /// file is for null, and is thus not represented here. As such all indices @@ -191,17 +193,46 @@ class BitcodeReader : public GVMaterializer { /// not need this flag. bool UseRelativeIDs; + static const error_category &BitcodeErrorCategory(); + public: + enum ErrorType { + BitcodeStreamInvalidSize, + ConflictingMETADATA_KINDRecords, + CouldNotFindFunctionInStream, + ExpectedConstant, + InsufficientFunctionProtos, + InvalidBitcodeSignature, + InvalidBitcodeWrapperHeader, + InvalidConstantReference, + InvalidID, // A read identifier is not found in the table it should be in. + InvalidInstructionWithNoBB, + InvalidRecord, // A read record doesn't have the expected size or structure + InvalidTypeForValue, // Type read OK, but is invalid for its use + InvalidTYPETable, + InvalidType, // We were unable to read a type + MalformedBlock, // We are unable to advance in the stream. + MalformedGlobalInitializerSet, + InvalidMultipleBlocks, // We found multiple blocks of a kind that should + // have only one + NeverResolvedValueFoundInFunction, + InvalidValue // Invalid version, inst number, attr number, etc + }; + + error_code Error(ErrorType E) { + return error_code(E, BitcodeErrorCategory()); + } + explicit BitcodeReader(MemoryBuffer *buffer, LLVMContext &C) : Context(C), TheModule(0), Buffer(buffer), BufferOwned(false), LazyStreamer(0), NextUnreadBit(0), SeenValueSymbolTable(false), - ErrorString(0), ValueList(C), MDValueList(C), + ValueList(C), MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false) { } explicit BitcodeReader(DataStreamer *streamer, LLVMContext &C) : Context(C), TheModule(0), Buffer(0), BufferOwned(false), LazyStreamer(streamer), NextUnreadBit(0), SeenValueSymbolTable(false), - ErrorString(0), ValueList(C), MDValueList(C), + ValueList(C), MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false) { } ~BitcodeReader() { @@ -218,23 +249,17 @@ public: virtual bool isMaterializable(const GlobalValue *GV) const; virtual bool isDematerializable(const GlobalValue *GV) const; - virtual bool Materialize(GlobalValue *GV, std::string *ErrInfo = 0); - virtual bool MaterializeModule(Module *M, std::string *ErrInfo = 0); + virtual error_code Materialize(GlobalValue *GV); + virtual error_code MaterializeModule(Module *M); virtual void Dematerialize(GlobalValue *GV); - bool Error(const char *Str) { - ErrorString = Str; - return true; - } - const char *getErrorString() const { return ErrorString; } - /// @brief Main interface to parsing a bitcode buffer. /// @returns true if an error occurred. - bool ParseBitcodeInto(Module *M); + error_code ParseBitcodeInto(Module *M); /// @brief Cheap mechanism to just extract module triple /// @returns true if an error occurred. - bool ParseTriple(std::string &Triple); + error_code ParseTriple(std::string &Triple); static uint64_t decodeSignRotatedValue(uint64_t V); @@ -258,7 +283,7 @@ private: /// getValueTypePair - Read a value/type pair out of the specified record from /// slot 'Slot'. Increment Slot past the number of slots used in the record. /// Return true on failure. - bool getValueTypePair(SmallVector<uint64_t, 64> &Record, unsigned &Slot, + bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot, unsigned InstNum, Value *&ResVal) { if (Slot == Record.size()) return true; unsigned ValNo = (unsigned)Record[Slot++]; @@ -282,7 +307,7 @@ private: /// popValue - Read a value out of the specified record from slot 'Slot'. /// Increment Slot past the number of slots used by the value in the record. /// Return true if there is an error. - bool popValue(SmallVector<uint64_t, 64> &Record, unsigned &Slot, + bool popValue(SmallVectorImpl<uint64_t> &Record, unsigned &Slot, unsigned InstNum, Type *Ty, Value *&ResVal) { if (getValue(Record, Slot, InstNum, Ty, ResVal)) return true; @@ -292,7 +317,7 @@ private: } /// getValue -- Like popValue, but does not increment the Slot number. - bool getValue(SmallVector<uint64_t, 64> &Record, unsigned Slot, + bool getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot, unsigned InstNum, Type *Ty, Value *&ResVal) { ResVal = getValue(Record, Slot, InstNum, Ty); return ResVal == 0; @@ -300,7 +325,7 @@ private: /// getValue -- Version of getValue that returns ResVal directly, /// or 0 if there is an error. - Value *getValue(SmallVector<uint64_t, 64> &Record, unsigned Slot, + Value *getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot, unsigned InstNum, Type *Ty) { if (Slot == Record.size()) return 0; unsigned ValNo = (unsigned)Record[Slot]; @@ -311,7 +336,7 @@ private: } /// getValueSigned -- Like getValue, but decodes signed VBRs. - Value *getValueSigned(SmallVector<uint64_t, 64> &Record, unsigned Slot, + Value *getValueSigned(SmallVectorImpl<uint64_t> &Record, unsigned Slot, unsigned InstNum, Type *Ty) { if (Slot == Record.size()) return 0; unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]); @@ -321,26 +346,27 @@ private: return getFnValueByID(ValNo, Ty); } - bool ParseModule(bool Resume); - bool ParseAttributeBlock(); - bool ParseAttributeGroupBlock(); - bool ParseTypeTable(); - bool ParseTypeTableBody(); - - bool ParseValueSymbolTable(); - bool ParseConstants(); - bool RememberAndSkipFunctionBody(); - bool ParseFunctionBody(Function *F); - bool GlobalCleanup(); - bool ResolveGlobalAndAliasInits(); - bool ParseMetadata(); - bool ParseMetadataAttachment(); - bool ParseModuleTriple(std::string &Triple); - bool ParseUseLists(); - bool InitStream(); - bool InitStreamFromBuffer(); - bool InitLazyStream(); - bool FindFunctionInStream(Function *F, + error_code ParseAttrKind(uint64_t Code, Attribute::AttrKind *Kind); + error_code ParseModule(bool Resume); + error_code ParseAttributeBlock(); + error_code ParseAttributeGroupBlock(); + error_code ParseTypeTable(); + error_code ParseTypeTableBody(); + + error_code ParseValueSymbolTable(); + error_code ParseConstants(); + error_code RememberAndSkipFunctionBody(); + error_code ParseFunctionBody(Function *F); + error_code GlobalCleanup(); + error_code ResolveGlobalAndAliasInits(); + error_code ParseMetadata(); + error_code ParseMetadataAttachment(); + error_code ParseModuleTriple(std::string &Triple); + error_code ParseUseLists(); + error_code InitStream(); + error_code InitStreamFromBuffer(); + error_code InitLazyStream(); + error_code FindFunctionInStream(Function *F, DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator); }; diff --git a/contrib/llvm/lib/Bitcode/Reader/BitstreamReader.cpp b/contrib/llvm/lib/Bitcode/Reader/BitstreamReader.cpp index 9dafe2a..1fd9abd 100644 --- a/contrib/llvm/lib/Bitcode/Reader/BitstreamReader.cpp +++ b/contrib/llvm/lib/Bitcode/Reader/BitstreamReader.cpp @@ -204,7 +204,16 @@ unsigned BitstreamCursor::readRecord(unsigned AbbrevID, const BitCodeAbbrev *Abbv = getAbbrev(AbbrevID); - for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) { + // Read the record code first. + assert(Abbv->getNumOperandInfos() != 0 && "no record code in abbreviation?"); + const BitCodeAbbrevOp &CodeOp = Abbv->getOperandInfo(0); + if (CodeOp.isLiteral()) + readAbbreviatedLiteral(CodeOp, Vals); + else + readAbbreviatedField(CodeOp, Vals); + unsigned Code = (unsigned)Vals.pop_back_val(); + + for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) { const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); if (Op.isLiteral()) { readAbbreviatedLiteral(Op, Vals); @@ -264,8 +273,6 @@ unsigned BitstreamCursor::readRecord(unsigned AbbrevID, JumpToBit(NewEnd); } - unsigned Code = (unsigned)Vals[0]; - Vals.erase(Vals.begin()); return Code; } |
