X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FBitcode%2FReader%2FBitcodeReader.cpp;h=5e358d9cc5480f6049879a3be0ed977924c932be;hp=29c603ff9895cde82e8ca23f37f768973bee1193;hb=36b699f2b139a30a2dfa4448223d6985b55daa8a;hpb=3defc0bfa600cc253f0cba0fe781aa49435d968a diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 29c603ff989..5e358d9cc54 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -6,26 +6,25 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -// -// This header defines the BitcodeReader class. -// -//===----------------------------------------------------------------------===// #include "llvm/Bitcode/ReaderWriter.h" #include "BitcodeReader.h" -#include "llvm/Constants.h" -#include "llvm/DerivedTypes.h" -#include "llvm/InlineAsm.h" -#include "llvm/IntrinsicInst.h" -#include "llvm/Module.h" -#include "llvm/Operator.h" -#include "llvm/AutoUpgrade.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/Bitcode/LLVMBitCodes.h" +#include "llvm/IR/AutoUpgrade.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/OperandTraits.h" +#include "llvm/Support/raw_ostream.h" using namespace llvm; enum { @@ -47,7 +46,7 @@ void BitcodeReader::FreeState() { ValueList.clear(); MDValueList.clear(); - std::vector().swap(MAttributes); + std::vector().swap(MAttributes); std::vector().swap(FunctionBBs); std::vector().swap(FunctionsWithBodies); DeferredFunctionInfo.clear(); @@ -81,8 +80,8 @@ static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { case 2: return GlobalValue::AppendingLinkage; case 3: return GlobalValue::InternalLinkage; case 4: return GlobalValue::LinkOnceAnyLinkage; - case 5: return GlobalValue::DLLImportLinkage; - case 6: return GlobalValue::DLLExportLinkage; + case 5: return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage + case 6: return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage case 7: return GlobalValue::ExternalWeakLinkage; case 8: return GlobalValue::CommonLinkage; case 9: return GlobalValue::PrivateLinkage; @@ -91,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; } } @@ -104,6 +102,16 @@ static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { } } +static GlobalValue::DLLStorageClassTypes +GetDecodedDLLStorageClass(unsigned Val) { + switch (Val) { + default: // Map unknown values to default. + case 0: return GlobalValue::DefaultStorageClass; + case 1: return GlobalValue::DLLImportStorageClass; + case 2: return GlobalValue::DLLExportStorageClass; + } +} + static GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { switch (Val) { case 0: return GlobalVariable::NotThreadLocal; @@ -130,6 +138,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) { @@ -194,6 +203,13 @@ static SynchronizationScope GetDecodedSynchScope(unsigned Val) { } } +static void UpgradeDLLImportExportLinkage(llvm::GlobalValue *GV, unsigned Val) { + switch (Val) { + case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break; + case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break; + } +} + namespace llvm { namespace { /// @brief A class for maintaining the slot number definition @@ -316,7 +332,7 @@ void BitcodeReaderValueList::ResolveConstantForwardRefs() { // new value. If they reference more than one placeholder, update them all // at once. while (!Placeholder->use_empty()) { - Value::use_iterator UI = Placeholder->use_begin(); + auto UI = Placeholder->user_begin(); User *U = *UI; // If the using object isn't uniqued, just update the operands. This @@ -409,7 +425,7 @@ Value *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { } // Create and return a placeholder, which will later be RAUW'd. - Value *V = MDNode::getTemporary(Context, ArrayRef()); + Value *V = MDNode::getTemporary(Context, None); MDValuePtrs[Idx] = V; return V; } @@ -432,62 +448,77 @@ Type *BitcodeReader::getTypeByID(unsigned ID) { // Functions for parsing blocks from the bitcode file //===----------------------------------------------------------------------===// -bool BitcodeReader::ParseAttributeBlock() { + +/// \brief This fills an AttrBuilder object with the LLVM attributes that have +/// been decoded from the given integer. This function must stay in sync with +/// 'encodeLLVMAttributesForBitcode'. +static void decodeLLVMAttributesForBitcode(AttrBuilder &B, + uint64_t EncodedAttrs) { + // FIXME: Remove in 4.0. + + // The alignment is stored as a 16-bit raw value from bits 31--16. We shift + // the bits above 31 down by 11 bits. + unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; + assert((!Alignment || isPowerOf2_32(Alignment)) && + "Alignment must be a power of two."); + + if (Alignment) + B.addAlignmentAttr(Alignment); + B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | + (EncodedAttrs & 0xffff)); +} + +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 Record; - SmallVector Attrs; + SmallVector Attrs; // Read all the records. while (1) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) { - if (Stream.ReadBlockEnd()) - return Error("Error at end of PARAMATTR block"); - return false; - } + BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - if (Code == bitc::ENTER_SUBBLOCK) { - // No known subblocks, always skip them. - Stream.ReadSubBlockID(); - if (Stream.SkipBlock()) - return Error("Malformed block record"); - continue; - } - - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; + switch (Entry.Kind) { + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + return error_code::success(); + case BitstreamEntry::Record: + // The interesting case. + break; } // Read a record. Record.clear(); - switch (Stream.ReadRecord(Code, Record)) { + switch (Stream.readRecord(Entry.ID, Record)) { default: // Default behavior: ignore. break; - case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...] + 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) { - Attributes ReconstitutedAttr = - Attributes::decodeLLVMAttributesForBitcode(Context, Record[i+1]); - Record[i+1] = ReconstitutedAttr.Raw(); + AttrBuilder B; + decodeLLVMAttributesForBitcode(B, Record[i+1]); + Attrs.push_back(AttributeSet::get(Context, Record[i], B)); } - for (unsigned i = 0, e = Record.size(); i != e; i += 2) { - AttrBuilder B(Record[i+1]); - if (B.hasAttributes()) - Attrs.push_back(AttributeWithIndex::get(Record[i], - Attributes::get(Context, B))); - } + MAttributes.push_back(AttributeSet::get(Context, Attrs)); + Attrs.clear(); + break; + } + case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] + for (unsigned i = 0, e = Record.size(); i != e; ++i) + Attrs.push_back(MAttributeGroups[Record[i]]); - MAttributes.push_back(AttrListPtr::get(Context, Attrs)); + MAttributes.push_back(AttributeSet::get(Context, Attrs)); Attrs.clear(); break; } @@ -495,16 +526,190 @@ bool BitcodeReader::ParseAttributeBlock() { } } -bool BitcodeReader::ParseTypeTable() { +// 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_IN_ALLOCA: + return Attribute::InAlloca; + 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(InvalidRecord); + + if (!MAttributeGroups.empty()) + return Error(InvalidMultipleBlocks); + + SmallVector Record; + + // Read all the records. + while (1) { + BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); + + switch (Entry.Kind) { + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + return error_code::success(); + case BitstreamEntry::Record: + // The interesting case. + break; + } + + // Read a record. + Record.clear(); + switch (Stream.readRecord(Entry.ID, Record)) { + default: // Default behavior: ignore. + break; + case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...] + if (Record.size() < 3) + return Error(InvalidRecord); + + uint64_t GrpID = Record[0]; + uint64_t Idx = Record[1]; // Index of the object this attribute refers to. + + AttrBuilder B; + for (unsigned i = 2, e = Record.size(); i != e; ++i) { + if (Record[i] == 0) { // Enum attribute + Attribute::AttrKind Kind; + if (error_code EC = ParseAttrKind(Record[++i], &Kind)) + return EC; + + B.addAttribute(Kind); + } else if (Record[i] == 1) { // Align attribute + 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]); + } else { // String attribute + assert((Record[i] == 3 || Record[i] == 4) && + "Invalid attribute group entry"); + bool HasValue = (Record[i++] == 4); + SmallString<64> KindStr; + SmallString<64> ValStr; + + while (Record[i] != 0 && i != e) + KindStr += Record[i++]; + assert(Record[i] == 0 && "Kind string not null terminated"); + + if (HasValue) { + // Has a value associated with it. + ++i; // Skip the '0' that terminates the "kind" string. + while (Record[i] != 0 && i != e) + ValStr += Record[i++]; + assert(Record[i] == 0 && "Value string not null terminated"); + } + + B.addAttribute(KindStr.str(), ValStr.str()); + } + } + + MAttributeGroups[GrpID] = AttributeSet::get(Context, Idx, B); + break; + } + } + } +} + +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 Record; unsigned NumRecords = 0; @@ -513,38 +718,32 @@ bool BitcodeReader::ParseTypeTableBody() { // Read all the records for this type table. while (1) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) { - if (NumRecords != TypeList.size()) - return Error("Invalid type forward reference in TYPE_BLOCK"); - if (Stream.ReadBlockEnd()) - return Error("Error at end of type table block"); - return false; - } + BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - if (Code == bitc::ENTER_SUBBLOCK) { - // No known subblocks, always skip them. - Stream.ReadSubBlockID(); - if (Stream.SkipBlock()) - return Error("Malformed block record"); - continue; - } - - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; + switch (Entry.Kind) { + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + if (NumRecords != TypeList.size()) + return Error(MalformedBlock); + return error_code::success(); + case BitstreamEntry::Record: + // The interesting case. + break; } // Read a record. Record.clear(); Type *ResultTy = 0; - switch (Stream.ReadRecord(Code, Record)) { - default: return Error("unknown type in type table"); + switch (Stream.readRecord(Entry.ID, Record)) { + 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 @@ -579,19 +778,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; } @@ -599,7 +799,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 ArgTys; for (unsigned i = 3, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -610,7 +810,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; @@ -618,7 +818,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 ArgTys; for (unsigned i = 2, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -629,14 +829,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 EltTys; for (unsigned i = 1, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -645,21 +845,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(TypeList[NumRecords]); @@ -678,17 +878,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(TypeList[NumRecords]); @@ -703,69 +903,63 @@ 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 Record; // Read all the records for this value table. SmallString<128> ValueName; while (1) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) { - if (Stream.ReadBlockEnd()) - return Error("Error at end of value symbol table block"); - return false; - } - if (Code == bitc::ENTER_SUBBLOCK) { - // No known subblocks, always skip them. - Stream.ReadSubBlockID(); - if (Stream.SkipBlock()) - return Error("Malformed block record"); - continue; - } + BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; + switch (Entry.Kind) { + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + return error_code::success(); + case BitstreamEntry::Record: + // The interesting case. + break; } // Read a record. Record.clear(); - switch (Stream.ReadRecord(Code, Record)) { + switch (Stream.readRecord(Entry.ID, Record)) { default: // Default behavior: unknown type. 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())); @@ -774,10 +968,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(); @@ -787,51 +981,44 @@ 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 Record; // Read all the records. while (1) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) { - if (Stream.ReadBlockEnd()) - return Error("Error at end of PARAMATTR block"); - return false; - } - - if (Code == bitc::ENTER_SUBBLOCK) { - // No known subblocks, always skip them. - Stream.ReadSubBlockID(); - if (Stream.SkipBlock()) - return Error("Malformed block record"); - continue; - } + BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; + switch (Entry.Kind) { + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + return error_code::success(); + case BitstreamEntry::Record: + // The interesting case. + break; } bool IsFunctionLocal = false; // Read a record. Record.clear(); - Code = Stream.ReadRecord(Code, Record); + unsigned Code = Stream.readRecord(Entry.ID, Record); switch (Code) { default: // Default behavior: ignore. break; case bitc::METADATA_NAME: { - // Read named of the named metadata. + // Read name of the named metadata. SmallString<8> Name(Record.begin(), Record.end()); Record.clear(); Code = Stream.ReadCode(); // METADATA_NAME is always followed by METADATA_NAMED_NODE. - unsigned NextBitCode = Stream.ReadRecord(Code, Record); + unsigned NextBitCode = Stream.readRecord(Code, Record); assert(NextBitCode == bitc::METADATA_NAMED_NODE); (void)NextBitCode; // Read named metadata elements. @@ -840,7 +1027,7 @@ bool BitcodeReader::ParseMetadata() { for (unsigned i = 0; i != Size; ++i) { MDNode *MD = dyn_cast(MDValueList.getValueFwdRef(Record[i])); if (MD == 0) - return Error("Malformed metadata record"); + return Error(InvalidRecord); NMD->addOperand(MD); } break; @@ -850,13 +1037,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 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()) @@ -877,14 +1065,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; } } @@ -904,12 +1092,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 > GlobalInitWorklist; std::vector > AliasInitWorklist; + std::vector > FunctionPrefixWorklist; GlobalInitWorklist.swap(GlobalInits); AliasInitWorklist.swap(AliasInits); + FunctionPrefixWorklist.swap(FunctionPrefixes); while (!GlobalInitWorklist.empty()) { unsigned ValID = GlobalInitWorklist.back().second; @@ -920,7 +1110,7 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast(ValueList[ValID])) GlobalInitWorklist.back().first->setInitializer(C); else - return Error("Global variable initializer is not a constant!"); + return Error(ExpectedConstant); } GlobalInitWorklist.pop_back(); } @@ -933,11 +1123,25 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast(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(ValueList[ValID])) + FunctionPrefixWorklist.back().first->setPrefixData(C); + else + return Error(ExpectedConstant); + } + FunctionPrefixWorklist.pop_back(); + } + + return error_code::success(); } static APInt ReadWideAPInt(ArrayRef Vals, unsigned TypeBits) { @@ -948,9 +1152,9 @@ static APInt ReadWideAPInt(ArrayRef 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 Record; @@ -958,27 +1162,29 @@ bool BitcodeReader::ParseConstants() { Type *CurTy = Type::getInt32Ty(Context); unsigned NextCstNo = ValueList.size(); while (1) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) - break; + BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - if (Code == bitc::ENTER_SUBBLOCK) { - // No known subblocks, always skip them. - Stream.ReadSubBlockID(); - if (Stream.SkipBlock()) - return Error("Malformed block record"); - continue; - } + switch (Entry.Kind) { + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + if (NextCstNo != ValueList.size()) + return Error(InvalidConstantReference); - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; + // Once all the constants have been read, go through and resolve forward + // references. + ValueList.ResolveConstantForwardRefs(); + return error_code::success(); + case BitstreamEntry::Record: + // The interesting case. + break; } // Read a record. Record.clear(); Value *V = 0; - unsigned BitCode = Stream.ReadRecord(Code, Record); + unsigned BitCode = Stream.readRecord(Entry.ID, Record); switch (BitCode) { default: // Default behavior: unknown constant case bitc::CST_CODE_UNDEF: // UNDEF @@ -986,9 +1192,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 @@ -996,12 +1202,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(CurTy)->getBitWidth()); @@ -1011,23 +1217,29 @@ 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(APInt(16, (uint16_t)Record[0]))); + V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, + APInt(16, (uint16_t)Record[0]))); else if (CurTy->isFloatTy()) - V = ConstantFP::get(Context, APFloat(APInt(32, (uint32_t)Record[0]))); + V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, + APInt(32, (uint32_t)Record[0]))); else if (CurTy->isDoubleTy()) - V = ConstantFP::get(Context, APFloat(APInt(64, Record[0]))); + V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, + APInt(64, Record[0]))); else if (CurTy->isX86_FP80Ty()) { // Bits are not stored the same way as a normal i80 APInt, compensate. uint64_t Rearrange[2]; Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); Rearrange[1] = Record[0] >> 48; - V = ConstantFP::get(Context, APFloat(APInt(80, Rearrange))); + V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, + APInt(80, Rearrange))); } else if (CurTy->isFP128Ty()) - V = ConstantFP::get(Context, APFloat(APInt(128, Record), true)); + V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, + APInt(128, Record))); else if (CurTy->isPPC_FP128Ty()) - V = ConstantFP::get(Context, APFloat(APInt(128, Record))); + V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, + APInt(128, Record))); else V = UndefValue::get(CurTy); break; @@ -1035,7 +1247,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 Elts; @@ -1063,7 +1275,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, @@ -1072,7 +1284,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(CurTy)->getElementType(); unsigned Size = Record.size(); @@ -1117,13 +1329,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. @@ -1153,25 +1366,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 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 Indices(Elts.begin() + 1, Elts.end()); @@ -1180,19 +1398,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 + // vector. Otherwise, it must be a single bit. + if (VectorType *VTy = dyn_cast(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(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)); @@ -1202,7 +1432,7 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] VectorType *OpTy = dyn_cast(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()); @@ -1214,7 +1444,7 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] VectorType *OpTy = dyn_cast(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), @@ -1228,7 +1458,7 @@ bool BitcodeReader::ParseConstants() { VectorType *OpTy = dyn_cast_or_null(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), @@ -1238,9 +1468,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); @@ -1253,16 +1485,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]; @@ -1276,17 +1509,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]; @@ -1299,12 +1533,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(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. @@ -1312,7 +1549,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); @@ -1333,56 +1570,38 @@ bool BitcodeReader::ParseConstants() { ValueList.AssignValue(V, NextCstNo); ++NextCstNo; } - - if (NextCstNo != ValueList.size()) - return Error("Invalid constant reference!"); - - if (Stream.ReadBlockEnd()) - return Error("Error at end of constants block"); - - // Once all the constants have been read, go through and resolve forward - // references. - ValueList.ResolveConstantForwardRefs(); - return false; } -bool BitcodeReader::ParseUseLists() { +error_code BitcodeReader::ParseUseLists() { if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) - return Error("Malformed block record"); + return Error(InvalidRecord); SmallVector Record; // Read all the records. while (1) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) { - if (Stream.ReadBlockEnd()) - return Error("Error at end of use-list table block"); - return false; - } - - if (Code == bitc::ENTER_SUBBLOCK) { - // No known subblocks, always skip them. - Stream.ReadSubBlockID(); - if (Stream.SkipBlock()) - return Error("Malformed block record"); - continue; - } + BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; + switch (Entry.Kind) { + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + return error_code::success(); + case BitstreamEntry::Record: + // The interesting case. + break; } // Read a use list record. Record.clear(); - switch (Stream.ReadRecord(Code, Record)) { + switch (Stream.readRecord(Entry.ID, Record)) { default: // Default behavior: unknown type. break; 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; } @@ -1393,10 +1612,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(); @@ -1407,15 +1626,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(); @@ -1434,72 +1653,78 @@ bool BitcodeReader::GlobalCleanup() { // want lazy deserialization. std::vector >().swap(GlobalInits); std::vector >().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 Record; std::vector SectionTable; std::vector GCTable; // Read all the records for this module. - while (!Stream.AtEndOfStream()) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) { - if (Stream.ReadBlockEnd()) - return Error("Error at end of module block"); + while (1) { + BitstreamEntry Entry = Stream.advance(); + switch (Entry.Kind) { + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: return GlobalCleanup(); - } - if (Code == bitc::ENTER_SUBBLOCK) { - switch (Stream.ReadSubBlockID()) { + case BitstreamEntry::SubBlock: + 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 (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 @@ -1508,32 +1733,33 @@ 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; - } - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; + case BitstreamEntry::Record: + // The interesting case. + break; } + // Read a record. - switch (Stream.ReadRecord(Code, Record)) { + switch (Stream.readRecord(Entry.ID, Record)) { 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; @@ -1546,21 +1772,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; } @@ -1568,34 +1794,35 @@ 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; } // GLOBALVAR: [pointer type, isconst, initid, // linkage, alignment, section, visibility, threadlocal, - // unnamed_addr] + // unnamed_addr, dllstorageclass] 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(Ty)->getAddressSpace(); Ty = cast(Ty)->getElementType(); @@ -1605,7 +1832,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; @@ -1620,15 +1847,24 @@ bool BitcodeReader::ParseModule(bool Resume) { if (Record.size() > 8) UnnamedAddr = Record[8]; + bool ExternallyInitialized = false; + if (Record.size() > 9) + ExternallyInitialized = Record[9]; + GlobalVariable *NewGV = new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, - TLM, AddressSpace); + TLM, AddressSpace, ExternallyInitialized); NewGV->setAlignment(Alignment); if (!Section.empty()) NewGV->setSection(Section); NewGV->setVisibility(Visibility); NewGV->setUnnamedAddr(UnnamedAddr); + if (Record.size() > 10) + NewGV->setDLLStorageClass(GetDecodedDLLStorageClass(Record[10])); + else + UpgradeDLLImportExportLinkage(NewGV, Record[3]); + ValueList.push_back(NewGV); // Remember which value to use for the global initializer. @@ -1637,18 +1873,20 @@ bool BitcodeReader::ParseModule(bool Resume) { break; } // FUNCTION: [type, callingconv, isproto, linkage, paramattr, - // alignment, section, visibility, gc, unnamed_addr] + // alignment, section, visibility, gc, unnamed_addr, + // dllstorageclass] 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(cast(Ty)->getElementType()); if (!FTy) - return Error("Function not a pointer to function type!"); + return Error(InvalidTypeForValue); Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, "", TheModule); @@ -1661,19 +1899,27 @@ 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)); + + if (Record.size() > 11) + Func->setDLLStorageClass(GetDecodedDLLStorageClass(Record[11])); + else + UpgradeDLLImportExportLinkage(Func, Record[3]); + ValueList.push_back(Func); // If this is a function with a body, remember the prototype we are @@ -1685,20 +1931,25 @@ bool BitcodeReader::ParseModule(bool Resume) { break; } // ALIAS: [alias type, aliasee val#, linkage] - // ALIAS: [alias type, aliasee val#, linkage, visibility] + // ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass] 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); // Old bitcode files didn't have visibility field. if (Record.size() > 3) NewGA->setVisibility(GetDecodedVisibility(Record[3])); + if (Record.size() > 4) + NewGA->setDLLStorageClass(GetDecodedDLLStorageClass(Record[4])); + else + UpgradeDLLImportExportLinkage(NewGA, Record[2]); ValueList.push_back(NewGA); AliasInits.push_back(std::make_pair(NewGA, Record[1])); break; @@ -1707,20 +1958,19 @@ 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; } Record.clear(); } - - return Error("Premature end of bitstream"); } -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' || @@ -1729,103 +1979,100 @@ 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 (!Stream.AtEndOfStream()) { - unsigned Code = Stream.ReadCode(); + while (1) { + if (Stream.AtEndOfStream()) + return error_code::success(); - if (Code != bitc::ENTER_SUBBLOCK) { + BitstreamEntry Entry = + Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); - // The ranlib in xcode 4 will align archive members by appending newlines + switch (Entry.Kind) { + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + return error_code::success(); + + case BitstreamEntry::SubBlock: + switch (Entry.ID) { + case bitc::BLOCKINFO_BLOCK_ID: + if (Stream.ReadBlockInfoBlock()) + return Error(MalformedBlock); + break; + case bitc::MODULE_BLOCK_ID: + // Reject multiple MODULE_BLOCK's in a single bitstream. + if (TheModule) + return Error(InvalidMultipleBlocks); + TheModule = M; + if (error_code EC = ParseModule(false)) + return EC; + if (LazyStreamer) + return error_code::success(); + break; + default: + if (Stream.SkipBlock()) + return Error(InvalidRecord); + break; + } + continue; + case BitstreamEntry::Record: + // There should be no records in the top-level of blocks. + + // The ranlib in Xcode 4 will align archive members by appending newlines // to the end of them. If this file size is a multiple of 4 but not 8, we // have to read and ignore these final 4 bytes :-( - if (Stream.GetAbbrevIDWidth() == 2 && Code == 2 && + 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"); - } - - unsigned BlockID = Stream.ReadSubBlockID(); - - // We only know the MODULE subblock ID. - switch (BlockID) { - case bitc::BLOCKINFO_BLOCK_ID: - if (Stream.ReadBlockInfoBlock()) - return Error("Malformed BlockInfoBlock"); - 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"); - TheModule = M; - if (ParseModule(false)) - return true; - if (LazyStreamer) return false; - break; - default: - if (Stream.SkipBlock()) - return Error("Malformed block record"); - break; + return Error(InvalidRecord); } } - - return false; } -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 Record; // Read all the records for this module. - while (!Stream.AtEndOfStream()) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) { - if (Stream.ReadBlockEnd()) - return Error("Error at end of module block"); - - return false; - } - - if (Code == bitc::ENTER_SUBBLOCK) { - switch (Stream.ReadSubBlockID()) { - default: // Skip unknown content. - if (Stream.SkipBlock()) - return Error("Malformed block record"); - break; - } - continue; - } + while (1) { + BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; + switch (Entry.Kind) { + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + return error_code::success(); + case BitstreamEntry::Record: + // The interesting case. + break; } // Read a record. - switch (Stream.ReadRecord(Code, Record)) { + switch (Stream.readRecord(Entry.ID, Record)) { default: break; // Default behavior, ignore unknown content. 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; } } Record.clear(); } - - return Error("Premature end of bitstream"); } -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' || @@ -1834,81 +2081,86 @@ 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. - while (!Stream.AtEndOfStream()) { - unsigned Code = Stream.ReadCode(); + while (1) { + BitstreamEntry Entry = Stream.advance(); - if (Code != bitc::ENTER_SUBBLOCK) - return Error("Invalid record at top-level"); + switch (Entry.Kind) { + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + return error_code::success(); - unsigned BlockID = Stream.ReadSubBlockID(); + case BitstreamEntry::SubBlock: + if (Entry.ID == bitc::MODULE_BLOCK_ID) + return ParseModuleTriple(Triple); - // We only know the MODULE subblock ID. - switch (BlockID) { - case bitc::MODULE_BLOCK_ID: - if (ParseModuleTriple(Triple)) - return true; - break; - default: + // Ignore other sub-blocks. if (Stream.SkipBlock()) - return Error("Malformed block record"); - break; + return Error(MalformedBlock); + continue; + + case BitstreamEntry::Record: + Stream.skipRecord(Entry.ID); + continue; } } - - return false; } /// 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 Record; - while(1) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) { - if (Stream.ReadBlockEnd()) - return Error("Error at end of PARAMATTR block"); + while (1) { + BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); + + switch (Entry.Kind) { + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + return error_code::success(); + case BitstreamEntry::Record: + // The interesting case. break; } - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; - } + // Read a metadata attachment record. Record.clear(); - switch (Stream.ReadRecord(Code, Record)) { + switch (Stream.readRecord(Entry.ID, Record)) { default: // Default behavior: ignore. break; 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::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(Node)); + if (I->second == LLVMContext::MD_tbaa) + InstsWithTBAATag.push_back(Inst); } break; } } } - return false; } /// 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(); @@ -1927,51 +2179,55 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // Read all the records. SmallVector Record; while (1) { - unsigned Code = Stream.ReadCode(); - if (Code == bitc::END_BLOCK) { - if (Stream.ReadBlockEnd()) - return Error("Error at end of function block"); - break; - } + BitstreamEntry Entry = Stream.advance(); - if (Code == bitc::ENTER_SUBBLOCK) { - switch (Stream.ReadSubBlockID()) { + switch (Entry.Kind) { + case BitstreamEntry::Error: + return Error(MalformedBlock); + case BitstreamEntry::EndBlock: + goto OutOfRecordLoop; + + case BitstreamEntry::SubBlock: + 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; - } - if (Code == bitc::DEFINE_ABBREV) { - Stream.ReadAbbrevRecord(); - continue; + case BitstreamEntry::Record: + // The interesting case. + break; } // Read a record. Record.clear(); Instruction *I = 0; - unsigned BitCode = Stream.ReadRecord(Code, Record); + 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) @@ -1991,7 +2247,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; @@ -2004,7 +2261,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]; @@ -2024,10 +2281,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()) { @@ -2047,16 +2305,16 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { cast(I)->setIsExact(true); } else if (isa(I)) { FastMathFlags FMF; - FMF.UnsafeAlgebra = - 0 != (Record[OpNum] & (1 << bitc::FMF_UNSAFE_ALGEBRA)); - FMF.NoNaNs = - 0 != (Record[OpNum] & (1 << bitc::FMF_NO_NANS)); - FMF.NoInfs = - 0 != (Record[OpNum] & (1 << bitc::FMF_NO_INFS)); - FMF.NoSignedZeros = - 0 != (Record[OpNum] & (1 << bitc::FMF_NO_SIGNED_ZEROS)); - FMF.AllowReciprocal = - 0 != (Record[OpNum] & (1 << bitc::FMF_ALLOW_RECIPROCAL)); + if (0 != (Record[OpNum] & FastMathFlags::UnsafeAlgebra)) + FMF.setUnsafeAlgebra(); + if (0 != (Record[OpNum] & FastMathFlags::NoNaNs)) + FMF.setNoNaNs(); + if (0 != (Record[OpNum] & FastMathFlags::NoInfs)) + FMF.setNoInfs(); + if (0 != (Record[OpNum] & FastMathFlags::NoSignedZeros)) + FMF.setNoSignedZeros(); + if (0 != (Record[OpNum] & FastMathFlags::AllowReciprocal)) + FMF.setAllowReciprocal(); if (FMF.any()) I->setFastMathFlags(FMF); } @@ -2069,13 +2327,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; } @@ -2084,13 +2350,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 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); } @@ -2106,14 +2372,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 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); } @@ -2127,17 +2393,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 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); } @@ -2154,7 +2420,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); @@ -2169,18 +2435,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(Cond->getType())) { // expect 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); @@ -2193,7 +2459,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; @@ -2206,7 +2472,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast(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; @@ -2217,10 +2483,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; @@ -2238,7 +2504,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); @@ -2260,9 +2526,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); @@ -2270,10 +2536,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); @@ -2284,7 +2550,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); } @@ -2293,7 +2559,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(OpTy)->getBitWidth(); @@ -2301,7 +2570,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]; @@ -2310,7 +2579,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned CurIdx = 5; for (unsigned i = 0; i != NumCases; ++i) { - IntegersSubsetToBB CaseBuilder; + SmallVector CaseVals; unsigned NumItems = Record[CurIdx++]; for (unsigned ci = 0; ci != NumItems; ++ci) { bool isSingleNumber = Record[CurIdx++]; @@ -2330,20 +2599,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::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; } @@ -2351,12 +2622,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); @@ -2366,7 +2637,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); } @@ -2375,11 +2646,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); @@ -2388,7 +2659,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { IBI->addDestination(DestBB); } else { delete IBI; - return Error("Invalid INDIRECTBR record!"); + return Error(InvalidRecord); } } I = IBI; @@ -2397,8 +2668,9 @@ 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"); - AttrListPtr PAL = getAttributes(Record[0]); + if (Record.size() < 4) + return Error(InvalidRecord); + AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; BasicBlock *NormalBB = getBasicBlock(Record[2]); BasicBlock *UnwindBB = getBasicBlock(Record[3]); @@ -2406,7 +2678,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(Callee->getType()); FunctionType *FTy = !CalleeTy ? 0 : @@ -2415,24 +2687,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 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); } } @@ -2448,7 +2721,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; @@ -2459,9 +2732,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); @@ -2476,7 +2750,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; @@ -2487,12 +2762,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++]; @@ -2505,7 +2781,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 || @@ -2524,13 +2800,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(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; @@ -2540,7 +2817,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); @@ -2552,15 +2829,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, @@ -2575,7 +2852,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast(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); @@ -2589,15 +2866,15 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast(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); @@ -2614,10 +2891,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast(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(I)->setVolatile(Record[OpNum]); @@ -2632,14 +2909,14 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast(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(I)->setVolatile(Record[OpNum+1]); @@ -2648,11 +2925,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); @@ -2661,21 +2938,21 @@ 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); - AttrListPtr PAL = getAttributes(Record[0]); + AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; unsigned OpNum = 2; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error("Invalid CALL record"); + return Error(InvalidRecord); PointerType *OpTy = dyn_cast(Callee->getType()); FunctionType *FTy = 0; if (OpTy) FTy = dyn_cast(OpTy->getElementType()); if (!FTy || Record.size() < FTy->getNumParams()+OpNum) - return Error("Invalid CALL record"); + return Error(InvalidRecord); SmallVector Args; // Read the fixed params. @@ -2685,18 +2962,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); } } @@ -2711,12 +2989,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; @@ -2727,7 +3005,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); @@ -2742,6 +3020,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { ValueList.AssignValue(I, NextValueNo++); } +OutOfRecordLoop: + // Check the function list for unresolved values. if (Argument *A = dyn_cast(ValueList.back())) { if (A->getParent() == 0) { @@ -2752,7 +3032,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { delete A; } } - return Error("Never resolved value found in function!"); + return Error(NeverResolvedValueFoundInFunction); } } @@ -2768,7 +3048,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { 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])); @@ -2782,20 +3062,21 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { ValueList.shrinkTo(ModuleValueListSize); MDValueList.shrinkTo(ModuleMDValueListSize); std::vector().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::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(); } //===----------------------------------------------------------------------===// @@ -2811,39 +3092,39 @@ 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(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::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(), E = UpgradedIntrinsics.end(); I != E; ++I) { if (I->first != I->second) { - for (Value::use_iterator UI = I->first->use_begin(), - UE = I->first->use_end(); UI != UE; ) { + for (auto UI = I->first->user_begin(), UE = I->first->user_end(); + UI != UE;) { if (CallInst* CI = dyn_cast(*UI++)) UpgradeIntrinsicCall(CI, I->second); } } } - return false; + return error_code::success(); } bool BitcodeReader::isDematerializable(const GlobalValue *GV) const { @@ -2866,17 +3147,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. @@ -2890,8 +3172,8 @@ bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { for (std::vector >::iterator I = UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { if (I->first != I->second) { - for (Value::use_iterator UI = I->first->use_begin(), - UE = I->first->use_end(); UI != UE; ) { + for (auto UI = I->first->user_begin(), UE = I->first->user_end(); + UI != UE;) { if (CallInst* CI = dyn_cast(*UI++)) UpgradeIntrinsicCall(CI, I->second); } @@ -2902,38 +3184,43 @@ bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { } std::vector >().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); @@ -2941,11 +3228,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; @@ -2954,7 +3241,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 override { + return "llvm.bitcode"; + } + std::string message(int IE) const override { + BitcodeReader::ErrorType E = static_cast(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; } //===----------------------------------------------------------------------===// @@ -2963,18 +3307,14 @@ bool BitcodeReader::InitLazyStream() { /// getLazyBitcodeModule - lazy function-at-a-time loading from a file. /// -Module *llvm::getLazyBitcodeModule(MemoryBuffer *Buffer, - LLVMContext& Context, - std::string *ErrMsg) { +ErrorOr llvm::getLazyBitcodeModule(MemoryBuffer *Buffer, + LLVMContext &Context) { Module *M = new Module(Buffer->getBufferIdentifier(), Context); BitcodeReader *R = new BitcodeReader(Buffer, Context); M->setMaterializer(R); - if (R->ParseBitcodeInto(M)) { - if (ErrMsg) - *ErrMsg = R->getErrorString(); - + if (error_code EC = R->ParseBitcodeInto(M)) { delete M; // Also deletes R. - return 0; + return EC; } // Have the BitcodeReader dtor delete 'Buffer'. R->setBufferOwned(true); @@ -2992,9 +3332,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; } @@ -3002,21 +3342,21 @@ Module *llvm::getStreamedBitcodeModule(const std::string &name, return M; } -/// ParseBitcodeFile - Read the specified bitcode file, returning the module. -/// If an error occurs, return null and fill in *ErrMsg if non-null. -Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, - std::string *ErrMsg){ - Module *M = getLazyBitcodeModule(Buffer, Context, ErrMsg); - if (!M) return 0; +ErrorOr llvm::parseBitcodeFile(MemoryBuffer *Buffer, + LLVMContext &Context) { + ErrorOr ModuleOrErr = getLazyBitcodeModule(Buffer, Context); + if (!ModuleOrErr) + return ModuleOrErr; + Module *M = ModuleOrErr.get(); // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether // there was an error. static_cast(M->getMaterializer())->setBufferOwned(false); // Read in the entire module, and destroy the BitcodeReader. - if (M->MaterializeAllPermanently(ErrMsg)) { + if (error_code EC = M->materializeAllPermanently()) { delete M; - return 0; + return EC; } // TODO: Restore the use-lists to the in-memory state when the bitcode was @@ -3033,9 +3373,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;