diff options
Diffstat (limited to 'lib/Bitcode')
| -rw-r--r-- | lib/Bitcode/Reader/BitReader.cpp | 12 | ||||
| -rw-r--r-- | lib/Bitcode/Reader/BitcodeReader.cpp | 844 | ||||
| -rw-r--r-- | lib/Bitcode/Reader/BitcodeReader.h | 50 | ||||
| -rw-r--r-- | lib/Bitcode/Reader/Deserialize.cpp | 14 | ||||
| -rw-r--r-- | lib/Bitcode/Writer/BitWriter.cpp | 28 | ||||
| -rw-r--r-- | lib/Bitcode/Writer/BitcodeWriter.cpp | 571 | ||||
| -rw-r--r-- | lib/Bitcode/Writer/BitcodeWriterPass.cpp | 21 | ||||
| -rw-r--r-- | lib/Bitcode/Writer/Serialize.cpp | 9 | ||||
| -rw-r--r-- | lib/Bitcode/Writer/ValueEnumerator.cpp | 167 | ||||
| -rw-r--r-- | lib/Bitcode/Writer/ValueEnumerator.h | 23 |
10 files changed, 1100 insertions, 639 deletions
diff --git a/lib/Bitcode/Reader/BitReader.cpp b/lib/Bitcode/Reader/BitReader.cpp index e5b8f7c..f513d41 100644 --- a/lib/Bitcode/Reader/BitReader.cpp +++ b/lib/Bitcode/Reader/BitReader.cpp @@ -34,12 +34,12 @@ int LLVMParseBitcode(LLVMMemoryBufferRef MemBuf, return 0; } -int LLVMParseBitcodeInContext(LLVMMemoryBufferRef MemBuf, - LLVMContextRef ContextRef, +int LLVMParseBitcodeInContext(LLVMContextRef ContextRef, + LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutModule, char **OutMessage) { std::string Message; - *OutModule = wrap(ParseBitcodeFile(unwrap(MemBuf), *unwrap(ContextRef), + *OutModule = wrap(ParseBitcodeFile(unwrap(MemBuf), *unwrap(ContextRef), &Message)); if (!*OutModule) { if (OutMessage) @@ -70,13 +70,13 @@ int LLVMGetBitcodeModuleProvider(LLVMMemoryBufferRef MemBuf, return 0; } -int LLVMGetBitcodeModuleProviderInContext(LLVMMemoryBufferRef MemBuf, - LLVMContextRef ContextRef, +int LLVMGetBitcodeModuleProviderInContext(LLVMContextRef ContextRef, + LLVMMemoryBufferRef MemBuf, LLVMModuleProviderRef *OutMP, char **OutMessage) { std::string Message; - *OutMP = wrap(getBitcodeModuleProvider(unwrap(MemBuf), *unwrap(ContextRef), + *OutMP = wrap(getBitcodeModuleProvider(unwrap(MemBuf), *unwrap(ContextRef), &Message)); if (!*OutMP) { if (OutMessage) diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 5943de2..4eb12c6 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -16,9 +16,11 @@ #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/InlineAsm.h" -#include "llvm/Instructions.h" -#include "llvm/MDNode.h" +#include "llvm/IntrinsicInst.h" +#include "llvm/LLVMContext.h" +#include "llvm/Metadata.h" #include "llvm/Module.h" +#include "llvm/Operator.h" #include "llvm/AutoUpgrade.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" @@ -32,7 +34,8 @@ void BitcodeReader::FreeState() { Buffer = 0; std::vector<PATypeHolder>().swap(TypeList); ValueList.clear(); - + MDValueList.clear(); + std::vector<AttrListPtr>().swap(MAttributes); std::vector<BasicBlock*>().swap(FunctionBBs); std::vector<Function*>().swap(FunctionsWithBodies); @@ -50,7 +53,7 @@ static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, StrTy &Result) { if (Idx > Record.size()) return true; - + for (unsigned i = Idx, e = Record.size(); i != e; ++i) Result += (char)Record[i]; return false; @@ -59,19 +62,20 @@ static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { switch (Val) { default: // Map unknown/new linkages to external - case 0: return GlobalValue::ExternalLinkage; - case 1: return GlobalValue::WeakAnyLinkage; - 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 7: return GlobalValue::ExternalWeakLinkage; - case 8: return GlobalValue::CommonLinkage; - case 9: return GlobalValue::PrivateLinkage; + case 0: return GlobalValue::ExternalLinkage; + case 1: return GlobalValue::WeakAnyLinkage; + 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 7: return GlobalValue::ExternalWeakLinkage; + case 8: return GlobalValue::CommonLinkage; + case 9: return GlobalValue::PrivateLinkage; case 10: return GlobalValue::WeakODRLinkage; case 11: return GlobalValue::LinkOnceODRLinkage; case 12: return GlobalValue::AvailableExternallyLinkage; + case 13: return GlobalValue::LinkerPrivateLinkage; } } @@ -137,19 +141,19 @@ namespace { void *operator new(size_t s) { return User::operator new(s, 1); } - explicit ConstantPlaceHolder(const Type *Ty) + explicit ConstantPlaceHolder(const Type *Ty, LLVMContext& Context) : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { - Op<0>() = UndefValue::get(Type::Int32Ty); + Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); } - + /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const ConstantPlaceHolder *) { return true; } static bool classof(const Value *V) { - return isa<ConstantExpr>(V) && + return isa<ConstantExpr>(V) && cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; } - - + + /// Provide fast operand accessors //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); }; @@ -157,7 +161,7 @@ namespace { // FIXME: can we inherit this from ConstantExpr? template <> -struct OperandTraits<ConstantPlaceHolder> : FixedNumOperandTraits<1> { +struct OperandTraits<ConstantPlaceHolder> : public FixedNumOperandTraits<1> { }; } @@ -167,16 +171,16 @@ void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { push_back(V); return; } - + if (Idx >= size()) resize(Idx+1); - + WeakVH &OldV = ValuePtrs[Idx]; if (OldV == 0) { OldV = V; return; } - + // Handle constants and non-constants (e.g. instrs) differently for // efficiency. if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { @@ -189,7 +193,7 @@ void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { delete PrevVal; } } - + Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, const Type *Ty) { @@ -202,7 +206,7 @@ Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, } // Create and return a placeholder, which will later be RAUW'd. - Constant *C = new ConstantPlaceHolder(Ty); + Constant *C = new ConstantPlaceHolder(Ty, Context); ValuePtrs[Idx] = C; return C; } @@ -210,15 +214,15 @@ Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) { if (Idx >= size()) resize(Idx + 1); - + if (Value *V = ValuePtrs[Idx]) { assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); return V; } - + // No type specified, must be invalid reference. if (Ty == 0) return 0; - + // Create and return a placeholder, which will later be RAUW'd. Value *V = new Argument(Ty); ValuePtrs[Idx] = V; @@ -233,30 +237,30 @@ Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) { /// uses and rewrite all the place holders at once for any constant that uses /// a placeholder. void BitcodeReaderValueList::ResolveConstantForwardRefs() { - // Sort the values by-pointer so that they are efficient to look up with a + // Sort the values by-pointer so that they are efficient to look up with a // binary search. std::sort(ResolveConstants.begin(), ResolveConstants.end()); - + SmallVector<Constant*, 64> NewOps; - + while (!ResolveConstants.empty()) { Value *RealVal = operator[](ResolveConstants.back().second); Constant *Placeholder = ResolveConstants.back().first; ResolveConstants.pop_back(); - + // Loop over all users of the placeholder, updating them to reference the // 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(); - + // If the using object isn't uniqued, just update the operands. This // handles instructions and initializers for global variables. if (!isa<Constant>(*UI) || isa<GlobalValue>(*UI)) { UI.getUse().set(RealVal); continue; } - + // Otherwise, we have a constant that uses the placeholder. Replace that // constant with a new constant that has *all* placeholder uses updated. Constant *UserC = cast<Constant>(*UI); @@ -271,8 +275,8 @@ void BitcodeReaderValueList::ResolveConstantForwardRefs() { NewOp = RealVal; } else { // Otherwise, look up the placeholder in ResolveConstants. - ResolveConstantsTy::iterator It = - std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), + ResolveConstantsTy::iterator It = + std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), std::pair<Constant*, unsigned>(cast<Constant>(*I), 0)); assert(It != ResolveConstants.end() && It->first == *I); @@ -285,10 +289,11 @@ void BitcodeReaderValueList::ResolveConstantForwardRefs() { // Make the new constant. Constant *NewC; if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { - NewC = ConstantArray::get(UserCA->getType(), &NewOps[0], NewOps.size()); + NewC = ConstantArray::get(UserCA->getType(), &NewOps[0], + NewOps.size()); } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { - NewC = ConstantStruct::get(&NewOps[0], NewOps.size(), - UserCS->getType()->isPacked()); + NewC = ConstantStruct::get(Context, &NewOps[0], NewOps.size(), + UserCS->getType()->isPacked()); } else if (isa<ConstantVector>(UserC)) { NewC = ConstantVector::get(&NewOps[0], NewOps.size()); } else { @@ -296,29 +301,67 @@ void BitcodeReaderValueList::ResolveConstantForwardRefs() { NewC = cast<ConstantExpr>(UserC)->getWithOperands(&NewOps[0], NewOps.size()); } - + UserC->replaceAllUsesWith(NewC); UserC->destroyConstant(); NewOps.clear(); } - + // Update all ValueHandles, they should be the only users at this point. Placeholder->replaceAllUsesWith(RealVal); delete Placeholder; } } +void BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { + if (Idx == size()) { + push_back(V); + return; + } + + if (Idx >= size()) + resize(Idx+1); + + WeakVH &OldV = MDValuePtrs[Idx]; + if (OldV == 0) { + OldV = V; + return; + } + + // If there was a forward reference to this value, replace it. + Value *PrevVal = OldV; + OldV->replaceAllUsesWith(V); + delete PrevVal; + // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new + // value for Idx. + MDValuePtrs[Idx] = V; +} + +Value *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { + if (Idx >= size()) + resize(Idx + 1); + + if (Value *V = MDValuePtrs[Idx]) { + assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); + return V; + } + + // Create and return a placeholder, which will later be RAUW'd. + Value *V = new Argument(Type::getMetadataTy(Context)); + MDValuePtrs[Idx] = V; + return V; +} const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) { // If the TypeID is in range, return it. if (ID < TypeList.size()) return TypeList[ID].get(); if (!isTypeTable) return 0; - + // The type table allows forward references. Push as many Opaque types as // needed to get up to ID. while (TypeList.size() <= ID) - TypeList.push_back(OpaqueType::get()); + TypeList.push_back(OpaqueType::get(Context)); return TypeList.back().get(); } @@ -329,14 +372,14 @@ const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) { bool BitcodeReader::ParseAttributeBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) return Error("Malformed block record"); - + if (!MAttributes.empty()) return Error("Multiple PARAMATTR blocks found!"); - + SmallVector<uint64_t, 64> Record; - + SmallVector<AttributeWithIndex, 8> Attrs; - + // Read all the records. while (1) { unsigned Code = Stream.ReadCode(); @@ -345,7 +388,7 @@ bool BitcodeReader::ParseAttributeBlock() { return Error("Error at end of PARAMATTR block"); return false; } - + if (Code == bitc::ENTER_SUBBLOCK) { // No known subblocks, always skip them. Stream.ReadSubBlockID(); @@ -353,12 +396,12 @@ bool BitcodeReader::ParseAttributeBlock() { return Error("Malformed block record"); continue; } - + if (Code == bitc::DEFINE_ABBREV) { Stream.ReadAbbrevRecord(); continue; } - + // Read a record. Record.clear(); switch (Stream.ReadRecord(Code, Record)) { @@ -397,14 +440,14 @@ bool BitcodeReader::ParseAttributeBlock() { unsigned OldRetAttrs = (Attribute::NoUnwind|Attribute::NoReturn| Attribute::ReadOnly|Attribute::ReadNone); - + if (FnAttribute == Attribute::None && RetAttribute != Attribute::None && (RetAttribute & OldRetAttrs) != 0) { if (FnAttribute == Attribute::None) { // add a slot so they get added. Record.push_back(~0U); Record.push_back(0); } - + FnAttribute |= RetAttribute & OldRetAttrs; RetAttribute &= ~OldRetAttrs; } @@ -432,7 +475,7 @@ bool BitcodeReader::ParseAttributeBlock() { bool BitcodeReader::ParseTypeTable() { if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID)) return Error("Malformed block record"); - + if (!TypeList.empty()) return Error("Multiple TYPE_BLOCKs found!"); @@ -449,7 +492,7 @@ bool BitcodeReader::ParseTypeTable() { return Error("Error at end of type table block"); return false; } - + if (Code == bitc::ENTER_SUBBLOCK) { // No known subblocks, always skip them. Stream.ReadSubBlockID(); @@ -457,12 +500,12 @@ bool BitcodeReader::ParseTypeTable() { return Error("Malformed block record"); continue; } - + if (Code == bitc::DEFINE_ABBREV) { Stream.ReadAbbrevRecord(); continue; } - + // Read a record. Record.clear(); const Type *ResultTy = 0; @@ -478,46 +521,47 @@ bool BitcodeReader::ParseTypeTable() { TypeList.reserve(Record[0]); continue; case bitc::TYPE_CODE_VOID: // VOID - ResultTy = Type::VoidTy; + ResultTy = Type::getVoidTy(Context); break; case bitc::TYPE_CODE_FLOAT: // FLOAT - ResultTy = Type::FloatTy; + ResultTy = Type::getFloatTy(Context); break; case bitc::TYPE_CODE_DOUBLE: // DOUBLE - ResultTy = Type::DoubleTy; + ResultTy = Type::getDoubleTy(Context); break; case bitc::TYPE_CODE_X86_FP80: // X86_FP80 - ResultTy = Type::X86_FP80Ty; + ResultTy = Type::getX86_FP80Ty(Context); break; case bitc::TYPE_CODE_FP128: // FP128 - ResultTy = Type::FP128Ty; + ResultTy = Type::getFP128Ty(Context); break; case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 - ResultTy = Type::PPC_FP128Ty; + ResultTy = Type::getPPC_FP128Ty(Context); break; case bitc::TYPE_CODE_LABEL: // LABEL - ResultTy = Type::LabelTy; + ResultTy = Type::getLabelTy(Context); break; case bitc::TYPE_CODE_OPAQUE: // OPAQUE ResultTy = 0; break; case bitc::TYPE_CODE_METADATA: // METADATA - ResultTy = Type::MetadataTy; + ResultTy = Type::getMetadataTy(Context); break; case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] if (Record.size() < 1) return Error("Invalid Integer type record"); - - ResultTy = IntegerType::get(Record[0]); + + ResultTy = IntegerType::get(Context, Record[0]); break; - case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or + case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or // [pointee type, address space] if (Record.size() < 1) return Error("Invalid POINTER type record"); unsigned AddressSpace = 0; if (Record.size() == 2) AddressSpace = Record[1]; - ResultTy = PointerType::get(getTypeByID(Record[0], true), AddressSpace); + ResultTy = PointerType::get(getTypeByID(Record[0], true), + AddressSpace); break; } case bitc::TYPE_CODE_FUNCTION: { @@ -528,7 +572,7 @@ bool BitcodeReader::ParseTypeTable() { std::vector<const Type*> ArgTys; for (unsigned i = 3, e = Record.size(); i != e; ++i) ArgTys.push_back(getTypeByID(Record[i], true)); - + ResultTy = FunctionType::get(getTypeByID(Record[2], true), ArgTys, Record[0]); break; @@ -539,7 +583,7 @@ bool BitcodeReader::ParseTypeTable() { std::vector<const Type*> EltTys; for (unsigned i = 1, e = Record.size(); i != e; ++i) EltTys.push_back(getTypeByID(Record[i], true)); - ResultTy = StructType::get(EltTys, Record[0]); + ResultTy = StructType::get(Context, EltTys, Record[0]); break; } case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] @@ -553,10 +597,10 @@ bool BitcodeReader::ParseTypeTable() { ResultTy = VectorType::get(getTypeByID(Record[1], true), Record[0]); break; } - + if (NumRecords == TypeList.size()) { // If this is a new type slot, just append it. - TypeList.push_back(ResultTy ? ResultTy : OpaqueType::get()); + TypeList.push_back(ResultTy ? ResultTy : OpaqueType::get(Context)); ++NumRecords; } else if (ResultTy == 0) { // Otherwise, this was forward referenced, so an opaque type was created, @@ -568,14 +612,14 @@ bool BitcodeReader::ParseTypeTable() { // Resolve the opaque type to the real type now. assert(NumRecords < TypeList.size() && "Typelist imbalance"); const OpaqueType *OldTy = cast<OpaqueType>(TypeList[NumRecords++].get()); - + // Don't directly push the new type on the Tab. Instead we want to replace // the opaque type we previously inserted with the new concrete value. The // refinement from the abstract (opaque) type to the new type causes all // uses of the abstract type to use the concrete type (NewTy). This will // also cause the opaque type to be deleted. const_cast<OpaqueType*>(OldTy)->refineAbstractTypeTo(ResultTy); - + // This should have replaced the old opaque type with the new type in the // value table... or with a preexisting type that was already in the // system. Let's just make sure it did. @@ -589,9 +633,9 @@ bool BitcodeReader::ParseTypeTable() { bool BitcodeReader::ParseTypeSymbolTable() { if (Stream.EnterSubBlock(bitc::TYPE_SYMTAB_BLOCK_ID)) return Error("Malformed block record"); - + SmallVector<uint64_t, 64> Record; - + // Read all the records for this type table. std::string TypeName; while (1) { @@ -601,7 +645,7 @@ bool BitcodeReader::ParseTypeSymbolTable() { return Error("Error at end of type symbol table block"); return false; } - + if (Code == bitc::ENTER_SUBBLOCK) { // No known subblocks, always skip them. Stream.ReadSubBlockID(); @@ -609,12 +653,12 @@ bool BitcodeReader::ParseTypeSymbolTable() { return Error("Malformed block record"); continue; } - + if (Code == bitc::DEFINE_ABBREV) { Stream.ReadAbbrevRecord(); continue; } - + // Read a record. Record.clear(); switch (Stream.ReadRecord(Code, Record)) { @@ -639,7 +683,7 @@ bool BitcodeReader::ParseValueSymbolTable() { return Error("Malformed block record"); SmallVector<uint64_t, 64> Record; - + // Read all the records for this value table. SmallString<128> ValueName; while (1) { @@ -648,7 +692,7 @@ bool BitcodeReader::ParseValueSymbolTable() { 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(); @@ -656,12 +700,12 @@ bool BitcodeReader::ParseValueSymbolTable() { return Error("Malformed block record"); continue; } - + if (Code == bitc::DEFINE_ABBREV) { Stream.ReadAbbrevRecord(); continue; } - + // Read a record. Record.clear(); switch (Stream.ReadRecord(Code, Record)) { @@ -674,8 +718,8 @@ bool BitcodeReader::ParseValueSymbolTable() { if (ValueID >= ValueList.size()) return Error("Invalid Value ID in VST_ENTRY record"); Value *V = ValueList[ValueID]; - - V->setName(&ValueName[0], ValueName.size()); + + V->setName(StringRef(ValueName.data(), ValueName.size())); ValueName.clear(); break; } @@ -685,8 +729,8 @@ bool BitcodeReader::ParseValueSymbolTable() { BasicBlock *BB = getBasicBlock(Record[0]); if (BB == 0) return Error("Invalid BB ID in VST_BBENTRY record"); - - BB->setName(&ValueName[0], ValueName.size()); + + BB->setName(StringRef(ValueName.data(), ValueName.size())); ValueName.clear(); break; } @@ -694,12 +738,121 @@ bool BitcodeReader::ParseValueSymbolTable() { } } +bool BitcodeReader::ParseMetadata() { + unsigned NextValueNo = MDValueList.size(); + + if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) + return Error("Malformed block record"); + + SmallVector<uint64_t, 64> 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; + } + + if (Code == bitc::DEFINE_ABBREV) { + Stream.ReadAbbrevRecord(); + continue; + } + + // Read a record. + Record.clear(); + switch (Stream.ReadRecord(Code, Record)) { + default: // Default behavior: ignore. + break; + case bitc::METADATA_NAME: { + // Read named of the named metadata. + unsigned NameLength = Record.size(); + SmallString<8> Name; + Name.resize(NameLength); + for (unsigned i = 0; i != NameLength; ++i) + Name[i] = Record[i]; + Record.clear(); + Code = Stream.ReadCode(); + + // METADATA_NAME is always followed by METADATA_NAMED_NODE. + if (Stream.ReadRecord(Code, Record) != bitc::METADATA_NAMED_NODE) + assert ( 0 && "Inavlid Named Metadata record"); + + // Read named metadata elements. + unsigned Size = Record.size(); + SmallVector<MetadataBase*, 8> Elts; + for (unsigned i = 0; i != Size; ++i) { + Value *MD = MDValueList.getValueFwdRef(Record[i]); + if (MetadataBase *B = dyn_cast<MetadataBase>(MD)) + Elts.push_back(B); + } + Value *V = NamedMDNode::Create(Context, Name.str(), Elts.data(), + Elts.size(), TheModule); + MDValueList.AssignValue(V, NextValueNo++); + break; + } + case bitc::METADATA_NODE: { + if (Record.empty() || Record.size() % 2 == 1) + return Error("Invalid METADATA_NODE record"); + + unsigned Size = Record.size(); + SmallVector<Value*, 8> Elts; + for (unsigned i = 0; i != Size; i += 2) { + const Type *Ty = getTypeByID(Record[i], false); + if (Ty->isMetadataTy()) + Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); + else if (Ty != Type::getVoidTy(Context)) + Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); + else + Elts.push_back(NULL); + } + Value *V = MDNode::get(Context, &Elts[0], Elts.size()); + MDValueList.AssignValue(V, NextValueNo++); + break; + } + case bitc::METADATA_STRING: { + unsigned MDStringLength = Record.size(); + SmallString<8> String; + String.resize(MDStringLength); + for (unsigned i = 0; i != MDStringLength; ++i) + String[i] = Record[i]; + Value *V = MDString::get(Context, + StringRef(String.data(), String.size())); + MDValueList.AssignValue(V, NextValueNo++); + break; + } + case bitc::METADATA_KIND: { + unsigned RecordLength = Record.size(); + if (Record.empty() || RecordLength < 2) + return Error("Invalid METADATA_KIND record"); + SmallString<8> Name; + Name.resize(RecordLength-1); + unsigned Kind = Record[0]; + for (unsigned i = 1; i != RecordLength; ++i) + Name[i-1] = Record[i]; + MetadataContext &TheMetadata = Context.getMetadata(); + TheMetadata.MDHandlerNames[Name.str()] = Kind; + break; + } + } + } +} + /// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in /// the LSB for dense VBR encoding. static uint64_t DecodeSignRotatedValue(uint64_t V) { if ((V & 1) == 0) return V >> 1; - if (V != 1) + if (V != 1) return -(V >> 1); // There is no such thing as -0 with integers. "-0" really means MININT. return 1ULL << 63; @@ -710,7 +863,7 @@ static uint64_t DecodeSignRotatedValue(uint64_t V) { bool BitcodeReader::ResolveGlobalAndAliasInits() { std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; - + GlobalInitWorklist.swap(GlobalInits); AliasInitWorklist.swap(AliasInits); @@ -725,7 +878,7 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { else return Error("Global variable initializer is not a constant!"); } - GlobalInitWorklist.pop_back(); + GlobalInitWorklist.pop_back(); } while (!AliasInitWorklist.empty()) { @@ -738,26 +891,25 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { else return Error("Alias initializer is not a constant!"); } - AliasInitWorklist.pop_back(); + AliasInitWorklist.pop_back(); } return false; } - bool BitcodeReader::ParseConstants() { if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) return Error("Malformed block record"); SmallVector<uint64_t, 64> Record; - + // Read all the records for this value table. - const Type *CurTy = Type::Int32Ty; + const Type *CurTy = Type::getInt32Ty(Context); unsigned NextCstNo = ValueList.size(); while (1) { unsigned Code = Stream.ReadCode(); if (Code == bitc::END_BLOCK) break; - + if (Code == bitc::ENTER_SUBBLOCK) { // No known subblocks, always skip them. Stream.ReadSubBlockID(); @@ -765,16 +917,17 @@ bool BitcodeReader::ParseConstants() { return Error("Malformed block record"); continue; } - + if (Code == bitc::DEFINE_ABBREV) { Stream.ReadAbbrevRecord(); continue; } - + // Read a record. Record.clear(); Value *V = 0; - switch (Stream.ReadRecord(Code, Record)) { + unsigned BitCode = Stream.ReadRecord(Code, Record); + switch (BitCode) { default: // Default behavior: unknown constant case bitc::CST_CODE_UNDEF: // UNDEF V = UndefValue::get(CurTy); @@ -797,45 +950,46 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] if (!isa<IntegerType>(CurTy) || Record.empty()) return Error("Invalid WIDE_INTEGER record"); - + unsigned NumWords = Record.size(); SmallVector<uint64_t, 8> Words; Words.resize(NumWords); for (unsigned i = 0; i != NumWords; ++i) Words[i] = DecodeSignRotatedValue(Record[i]); - V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(), - NumWords, &Words[0])); + V = ConstantInt::get(Context, + APInt(cast<IntegerType>(CurTy)->getBitWidth(), + NumWords, &Words[0])); break; } case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] if (Record.empty()) return Error("Invalid FLOAT record"); - if (CurTy == Type::FloatTy) - V = ConstantFP::get(APFloat(APInt(32, (uint32_t)Record[0]))); - else if (CurTy == Type::DoubleTy) - V = ConstantFP::get(APFloat(APInt(64, Record[0]))); - else if (CurTy == Type::X86_FP80Ty) { + if (CurTy->isFloatTy()) + V = ConstantFP::get(Context, APFloat(APInt(32, (uint32_t)Record[0]))); + else if (CurTy->isDoubleTy()) + V = ConstantFP::get(Context, APFloat(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(APFloat(APInt(80, 2, Rearrange))); - } else if (CurTy == Type::FP128Ty) - V = ConstantFP::get(APFloat(APInt(128, 2, &Record[0]), true)); - else if (CurTy == Type::PPC_FP128Ty) - V = ConstantFP::get(APFloat(APInt(128, 2, &Record[0]))); + V = ConstantFP::get(Context, APFloat(APInt(80, 2, Rearrange))); + } else if (CurTy->isFP128Ty()) + V = ConstantFP::get(Context, APFloat(APInt(128, 2, &Record[0]), true)); + else if (CurTy->isPPC_FP128Ty()) + V = ConstantFP::get(Context, APFloat(APInt(128, 2, &Record[0]))); else V = UndefValue::get(CurTy); break; } - + case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] if (Record.empty()) return Error("Invalid CST_AGGREGATE record"); - + unsigned Size = Record.size(); std::vector<Constant*> Elts; - + if (const StructType *STy = dyn_cast<StructType>(CurTy)) { for (unsigned i = 0; i != Size; ++i) Elts.push_back(ValueList.getConstantFwdRef(Record[i], @@ -862,7 +1016,7 @@ bool BitcodeReader::ParseConstants() { const ArrayType *ATy = cast<ArrayType>(CurTy); const Type *EltTy = ATy->getElementType(); - + unsigned Size = Record.size(); std::vector<Constant*> Elts; for (unsigned i = 0; i != Size; ++i) @@ -873,10 +1027,10 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_CSTRING: { // CSTRING: [values] if (Record.empty()) return Error("Invalid CST_AGGREGATE record"); - + const ArrayType *ATy = cast<ArrayType>(CurTy); const Type *EltTy = ATy->getElementType(); - + unsigned Size = Record.size(); std::vector<Constant*> Elts; for (unsigned i = 0; i != Size; ++i) @@ -893,10 +1047,24 @@ bool BitcodeReader::ParseConstants() { } else { Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); - V = ConstantExpr::get(Opc, LHS, RHS); + unsigned Flags = 0; + if (Record.size() >= 4) { + if (Opc == Instruction::Add || + Opc == Instruction::Sub || + Opc == Instruction::Mul) { + if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) + Flags |= OverflowingBinaryOperator::NoSignedWrap; + if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) + Flags |= OverflowingBinaryOperator::NoUnsignedWrap; + } else if (Opc == Instruction::SDiv) { + if (Record[3] & (1 << bitc::SDIV_EXACT)) + Flags |= SDivOperator::IsExact; + } + } + V = ConstantExpr::get(Opc, LHS, RHS, Flags); } break; - } + } case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] if (Record.size() < 3) return Error("Invalid CE_CAST record"); int Opc = GetDecodedCastOpcode(Record[0]); @@ -909,7 +1077,8 @@ bool BitcodeReader::ParseConstants() { 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"); SmallVector<Constant*, 16> Elts; @@ -918,23 +1087,28 @@ bool BitcodeReader::ParseConstants() { if (!ElTy) return Error("Invalid CE_GEP record"); Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); } - V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1); + if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP) + V = ConstantExpr::getInBoundsGetElementPtr(Elts[0], &Elts[1], + Elts.size()-1); + else + V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], + Elts.size()-1); 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::Int1Ty), + Type::getInt1Ty(Context)), 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"); - const VectorType *OpTy = + const VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record"); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); - Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty); + Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); V = ConstantExpr::getExtractElement(Op0, Op1); break; } @@ -945,7 +1119,7 @@ bool BitcodeReader::ParseConstants() { Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy->getElementType()); - Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty); + Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); V = ConstantExpr::getInsertElement(Op0, Op1, Op2); break; } @@ -955,7 +1129,8 @@ bool BitcodeReader::ParseConstants() { return Error("Invalid CE_SHUFFLEVEC record"); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); - const Type *ShufTy=VectorType::get(Type::Int32Ty, OpTy->getNumElements()); + const Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), + OpTy->getNumElements()); Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); break; @@ -967,7 +1142,8 @@ bool BitcodeReader::ParseConstants() { return Error("Invalid CE_SHUFVEC_EX record"); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); - const Type *ShufTy=VectorType::get(Type::Int32Ty, RTy->getNumElements()); + const Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), + RTy->getNumElements()); Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); break; @@ -981,72 +1157,43 @@ bool BitcodeReader::ParseConstants() { if (OpTy->isFloatingPoint()) V = ConstantExpr::getFCmp(Record[3], Op0, Op1); - else if (!isa<VectorType>(OpTy)) - V = ConstantExpr::getICmp(Record[3], Op0, Op1); - else if (OpTy->isFPOrFPVector()) - V = ConstantExpr::getVFCmp(Record[3], Op0, Op1); else - V = ConstantExpr::getVICmp(Record[3], Op0, Op1); + V = ConstantExpr::getICmp(Record[3], Op0, Op1); break; } case bitc::CST_CODE_INLINEASM: { if (Record.size() < 2) return Error("Invalid INLINEASM record"); std::string AsmStr, ConstrStr; - bool HasSideEffects = Record[0]; + bool HasSideEffects = Record[0] & 1; + bool IsMsAsm = Record[0] >> 1; unsigned AsmStrSize = Record[1]; if (2+AsmStrSize >= Record.size()) return Error("Invalid INLINEASM record"); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) return Error("Invalid INLINEASM record"); - + for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; for (unsigned i = 0; i != ConstStrSize; ++i) ConstrStr += (char)Record[3+AsmStrSize+i]; const PointerType *PTy = cast<PointerType>(CurTy); V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), - AsmStr, ConstrStr, HasSideEffects); - break; - } - case bitc::CST_CODE_MDSTRING: { - if (Record.size() < 2) return Error("Invalid MDSTRING record"); - unsigned MDStringLength = Record.size(); - SmallString<8> String; - String.resize(MDStringLength); - for (unsigned i = 0; i != MDStringLength; ++i) - String[i] = Record[i]; - V = MDString::get(String.c_str(), String.c_str() + MDStringLength); - break; - } - case bitc::CST_CODE_MDNODE: { - if (Record.empty() || Record.size() % 2 == 1) - return Error("Invalid CST_MDNODE record"); - - unsigned Size = Record.size(); - SmallVector<Value*, 8> Elts; - for (unsigned i = 0; i != Size; i += 2) { - const Type *Ty = getTypeByID(Record[i], false); - if (Ty != Type::VoidTy) - Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); - else - Elts.push_back(NULL); - } - V = MDNode::get(&Elts[0], Elts.size()); + AsmStr, ConstrStr, HasSideEffects, IsMsAsm); break; } } - + 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(); @@ -1060,18 +1207,18 @@ bool BitcodeReader::RememberAndSkipFunctionBody() { // Get the function we are talking about. if (FunctionsWithBodies.empty()) return Error("Insufficient function protos"); - + Function *Fn = FunctionsWithBodies.back(); FunctionsWithBodies.pop_back(); - + // Save the current stream state. uint64_t CurBit = Stream.GetCurrentBitNo(); DeferredFunctionInfo[Fn] = std::make_pair(CurBit, Fn->getLinkage()); - + // Set the functions linkage to GhostLinkage so we know it is lazily // deserialized. Fn->setLinkage(GlobalValue::GhostLinkage); - + // Skip over the function block for now. if (Stream.SkipBlock()) return Error("Malformed block record"); @@ -1082,13 +1229,13 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { // Reject multiple MODULE_BLOCK's in a single bitstream. if (TheModule) return Error("Multiple MODULE_BLOCKs in same stream"); - + if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) return Error("Malformed block record"); // Otherwise, create the module. TheModule = new Module(ModuleID, Context); - + SmallVector<uint64_t, 64> Record; std::vector<std::string> SectionTable; std::vector<std::string> GCTable; @@ -1122,7 +1269,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { std::vector<Function*>().swap(FunctionsWithBodies); return false; } - + if (Code == bitc::ENTER_SUBBLOCK) { switch (Stream.ReadSubBlockID()) { default: // Skip unknown content. @@ -1153,6 +1300,10 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { if (ParseConstants() || ResolveGlobalAndAliasInits()) return true; break; + case bitc::METADATA_BLOCK_ID: + if (ParseMetadata()) + return true; + break; case bitc::FUNCTION_BLOCK_ID: // If this is the first function body we've seen, reverse the // FunctionsWithBodies list. @@ -1160,19 +1311,19 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); HasReversedFunctionsWithBodies = true; } - + if (RememberAndSkipFunctionBody()) return true; break; } continue; } - + if (Code == bitc::DEFINE_ABBREV) { Stream.ReadAbbrevRecord(); continue; } - + // Read a record. switch (Stream.ReadRecord(Code, Record)) { default: break; // Default behavior, ignore unknown content. @@ -1235,7 +1386,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { return Error("Global not a pointer type!"); unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); Ty = cast<PointerType>(Ty)->getElementType(); - + bool isConstant = Record[1]; GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); unsigned Alignment = (1 << Record[4]) >> 1; @@ -1253,16 +1404,16 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { isThreadLocal = Record[7]; GlobalVariable *NewGV = - new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule, + new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, isThreadLocal, AddressSpace); NewGV->setAlignment(Alignment); if (!Section.empty()) NewGV->setSection(Section); NewGV->setVisibility(Visibility); NewGV->setThreadLocal(isThreadLocal); - + ValueList.push_back(NewGV); - + // Remember which value to use for the global initializer. if (unsigned InitID = Record[2]) GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); @@ -1284,11 +1435,11 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, "", TheModule); - Func->setCallingConv(Record[1]); + Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); bool isProto = Record[2]; Func->setLinkage(GetDecodedLinkage(Record[3])); Func->setAttributes(getAttributes(Record[4])); - + Func->setAlignment((1 << Record[5]) >> 1); if (Record[6]) { if (Record[6]-1 >= SectionTable.size()) @@ -1302,7 +1453,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { Func->setGC(GCTable[Record[8]-1].c_str()); } ValueList.push_back(Func); - + // If this is a function with a body, remember the prototype we are // creating now, so that we can match up the body with them later. if (!isProto) @@ -1317,7 +1468,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { const Type *Ty = getTypeByID(Record[0]); if (!isa<PointerType>(Ty)) return Error("Function not a pointer type!"); - + GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), "", 0, TheModule); // Old bitcode files didn't have visibility field. @@ -1337,28 +1488,28 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { } Record.clear(); } - + return Error("Premature end of bitstream"); } bool BitcodeReader::ParseBitcode() { TheModule = 0; - + if (Buffer->getBufferSize() & 3) return Error("Bitcode stream should be a multiple of 4 bytes in length"); - + unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart(); unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); - + // 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)) return Error("Invalid bitcode wrapper header"); - + StreamFile.init(BufPtr, BufEnd); Stream.init(StreamFile); - + // Sniff for the signature. if (Stream.Read(8) != 'B' || Stream.Read(8) != 'C' || @@ -1367,17 +1518,17 @@ bool BitcodeReader::ParseBitcode() { Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) return Error("Invalid bitcode signature"); - + // 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(); - + if (Code != bitc::ENTER_SUBBLOCK) 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: @@ -1394,22 +1545,61 @@ bool BitcodeReader::ParseBitcode() { break; } } - + return false; } +/// ParseMetadataAttachment - Parse metadata attachments. +bool BitcodeReader::ParseMetadataAttachment() { + if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) + return Error("Malformed block record"); + + MetadataContext &TheMetadata = Context.getMetadata(); + SmallVector<uint64_t, 64> Record; + while(1) { + unsigned Code = Stream.ReadCode(); + if (Code == bitc::END_BLOCK) { + if (Stream.ReadBlockEnd()) + return Error("Error at end of PARAMATTR block"); + break; + } + if (Code == bitc::DEFINE_ABBREV) { + Stream.ReadAbbrevRecord(); + continue; + } + // Read a metadata attachment record. + Record.clear(); + switch (Stream.ReadRecord(Code, 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!"); + Instruction *Inst = InstructionList[Record[0]]; + for (unsigned i = 1; i != RecordLength; i = i+2) { + unsigned Kind = Record[i]; + Value *Node = MDValueList.getValueFwdRef(Record[i+1]); + TheMetadata.addMD(Kind, cast<MDNode>(Node), Inst); + } + break; + } + } + } + return false; +} /// ParseFunctionBody - Lazily parse the specified function body block. bool BitcodeReader::ParseFunctionBody(Function *F) { if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) return Error("Malformed block record"); - + unsigned ModuleValueListSize = ValueList.size(); - + // Add all the function arguments to the value table. for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) ValueList.push_back(I); - + unsigned NextValueNo = ValueList.size(); BasicBlock *CurBB = 0; unsigned CurBBNo = 0; @@ -1423,7 +1613,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { return Error("Error at end of function block"); break; } - + if (Code == bitc::ENTER_SUBBLOCK) { switch (Stream.ReadSubBlockID()) { default: // Skip unknown content. @@ -1437,19 +1627,23 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { case bitc::VALUE_SYMTAB_BLOCK_ID: if (ParseValueSymbolTable()) return true; break; + case bitc::METADATA_ATTACHMENT_ID: + if (ParseMetadataAttachment()) return true; + break; } continue; } - + if (Code == bitc::DEFINE_ABBREV) { Stream.ReadAbbrevRecord(); continue; } - + // Read a record. Record.clear(); Instruction *I = 0; - switch (Stream.ReadRecord(Code, Record)) { + unsigned BitCode = Stream.ReadRecord(Code, Record); + switch (BitCode) { default: // Default behavior: reject return Error("Unknown instruction"); case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] @@ -1458,21 +1652,35 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // Create all the basic blocks for the function. FunctionBBs.resize(Record[0]); for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) - FunctionBBs[i] = BasicBlock::Create("", F); + FunctionBBs[i] = BasicBlock::Create(Context, "", F); CurBB = FunctionBBs[0]; continue; - + case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] unsigned OpNum = 0; Value *LHS, *RHS; if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || getValue(Record, OpNum, LHS->getType(), RHS) || - OpNum+1 != Record.size()) + OpNum+1 > Record.size()) return Error("Invalid BINOP record"); - - int Opc = GetDecodedBinaryOpcode(Record[OpNum], LHS->getType()); + + int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); if (Opc == -1) return Error("Invalid BINOP record"); I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); + InstructionList.push_back(I); + if (OpNum < Record.size()) { + if (Opc == Instruction::Add || + Opc == Instruction::Sub || + Opc == Instruction::Mul) { + if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) + cast<BinaryOperator>(I)->setHasNoSignedWrap(true); + if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) + cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); + } else if (Opc == Instruction::SDiv) { + if (Record[3] & (1 << bitc::SDIV_EXACT)) + cast<BinaryOperator>(I)->setIsExact(true); + } + } break; } case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] @@ -1481,14 +1689,16 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) return Error("Invalid CAST record"); - + const 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); + InstructionList.push_back(I); break; } + case bitc::FUNC_CODE_INST_INBOUNDS_GEP: case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] unsigned OpNum = 0; Value *BasePtr; @@ -1504,9 +1714,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } I = GetElementPtrInst::Create(BasePtr, GEPIdx.begin(), GEPIdx.end()); + InstructionList.push_back(I); + if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) + cast<GetElementPtrInst>(I)->setIsInBounds(true); break; } - + case bitc::FUNC_CODE_INST_EXTRACTVAL: { // EXTRACTVAL: [opty, opval, n x indices] unsigned OpNum = 0; @@ -1525,9 +1738,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { I = ExtractValueInst::Create(Agg, EXTRACTVALIdx.begin(), EXTRACTVALIdx.end()); + InstructionList.push_back(I); break; } - + case bitc::FUNC_CODE_INST_INSERTVAL: { // INSERTVAL: [opty, opval, opty, opval, n x indices] unsigned OpNum = 0; @@ -1549,9 +1763,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { I = InsertValueInst::Create(Agg, Val, INSERTVALIdx.begin(), INSERTVALIdx.end()); + InstructionList.push_back(I); break; } - + case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] // obsolete form of select // handles select i1 ... in old bitcode @@ -1559,13 +1774,14 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *TrueVal, *FalseVal, *Cond; if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || getValue(Record, OpNum, TrueVal->getType(), FalseVal) || - getValue(Record, OpNum, Type::Int1Ty, Cond)) + getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) return Error("Invalid SELECT record"); - + I = SelectInst::Create(Cond, TrueVal, FalseVal); + InstructionList.push_back(I); break; } - + case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] // new form of select // handles select i1 or select [N x i1] @@ -1580,40 +1796,43 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (const VectorType* vector_type = dyn_cast<const VectorType>(Cond->getType())) { // expect <n x i1> - if (vector_type->getElementType() != Type::Int1Ty) + if (vector_type->getElementType() != Type::getInt1Ty(Context)) return Error("Invalid SELECT condition type"); } else { // expect i1 - if (Cond->getType() != Type::Int1Ty) + if (Cond->getType() != Type::getInt1Ty(Context)) return Error("Invalid SELECT condition type"); - } - + } + I = SelectInst::Create(Cond, TrueVal, FalseVal); + InstructionList.push_back(I); break; } - + case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] unsigned OpNum = 0; Value *Vec, *Idx; if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || - getValue(Record, OpNum, Type::Int32Ty, Idx)) + getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) return Error("Invalid EXTRACTELT record"); - I = new ExtractElementInst(Vec, Idx); + I = ExtractElementInst::Create(Vec, Idx); + InstructionList.push_back(I); break; } - + case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] unsigned OpNum = 0; Value *Vec, *Elt, *Idx; if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || - getValue(Record, OpNum, + getValue(Record, OpNum, cast<VectorType>(Vec->getType())->getElementType(), Elt) || - getValue(Record, OpNum, Type::Int32Ty, Idx)) + getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) return Error("Invalid INSERTELT record"); I = InsertElementInst::Create(Vec, Elt, Idx); + InstructionList.push_back(I); break; } - + case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] unsigned OpNum = 0; Value *Vec1, *Vec2, *Mask; @@ -1624,44 +1843,32 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) return Error("Invalid SHUFFLEVEC record"); I = new ShuffleVectorInst(Vec1, Vec2, Mask); + InstructionList.push_back(I); break; } - case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred] - // VFCmp/VICmp - // or old form of ICmp/FCmp returning bool - unsigned OpNum = 0; - Value *LHS, *RHS; - if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || - getValue(Record, OpNum, LHS->getType(), RHS) || - OpNum+1 != Record.size()) - return Error("Invalid CMP record"); - - if (LHS->getType()->isFloatingPoint()) - I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); - else if (!isa<VectorType>(LHS->getType())) - I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); - else if (LHS->getType()->isFPOrFPVector()) - I = new VFCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); - else - I = new VICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); - break; - } + case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] + // Old form of ICmp/FCmp returning bool + // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were + // both legal on vectors but had different behaviour. case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] - // Fcmp/ICmp returning bool or vector of bool + // FCmp/ICmp returning bool or vector of bool + unsigned OpNum = 0; Value *LHS, *RHS; if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || getValue(Record, OpNum, LHS->getType(), RHS) || OpNum+1 != Record.size()) - return Error("Invalid CMP2 record"); - + return Error("Invalid CMP record"); + if (LHS->getType()->isFPOrFPVector()) I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); - else + else I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); + InstructionList.push_back(I); break; } + case bitc::FUNC_CODE_INST_GETRESULT: { // GETRESULT: [ty, val, n] if (Record.size() != 2) return Error("Invalid GETRESULT record"); @@ -1670,14 +1877,16 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { getValueTypePair(Record, OpNum, NextValueNo, Op); unsigned Index = Record[1]; I = ExtractValueInst::Create(Op, Index); + InstructionList.push_back(I); break; } - + case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] { unsigned Size = Record.size(); if (Size == 0) { - I = ReturnInst::Create(); + I = ReturnInst::Create(Context); + InstructionList.push_back(I); break; } @@ -1697,15 +1906,18 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *RV = UndefValue::get(ReturnType); for (unsigned i = 0, e = Vs.size(); i != e; ++i) { I = InsertValueInst::Create(RV, Vs[i], i, "mrv"); + InstructionList.push_back(I); CurBB->getInstList().push_back(I); ValueList.AssignValue(I, NextValueNo++); RV = I; } - I = ReturnInst::Create(RV); + I = ReturnInst::Create(Context, RV); + InstructionList.push_back(I); break; } - I = ReturnInst::Create(Vs[0]); + I = ReturnInst::Create(Context, Vs[0]); + InstructionList.push_back(I); break; } case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] @@ -1715,14 +1927,17 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (TrueDest == 0) return Error("Invalid BR record"); - if (Record.size() == 1) + if (Record.size() == 1) { I = BranchInst::Create(TrueDest); + InstructionList.push_back(I); + } else { BasicBlock *FalseDest = getBasicBlock(Record[1]); - Value *Cond = getFnValueByID(Record[2], Type::Int1Ty); + Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); if (FalseDest == 0 || Cond == 0) return Error("Invalid BR record"); I = BranchInst::Create(TrueDest, FalseDest, Cond); + InstructionList.push_back(I); } break; } @@ -1736,8 +1951,9 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { return Error("Invalid SWITCH record"); unsigned NumCases = (Record.size()-3)/2; SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); + InstructionList.push_back(SI); for (unsigned i = 0, e = NumCases; i != e; ++i) { - ConstantInt *CaseVal = + ConstantInt *CaseVal = dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); if (CaseVal == 0 || DestBB == 0) { @@ -1749,7 +1965,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { I = SI; break; } - + case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] if (Record.size() < 4) return Error("Invalid INVOKE record"); @@ -1757,12 +1973,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned CCInfo = Record[1]; BasicBlock *NormalBB = getBasicBlock(Record[2]); BasicBlock *UnwindBB = getBasicBlock(Record[3]); - + unsigned OpNum = 4; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) return Error("Invalid INVOKE record"); - + const PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); const FunctionType *FTy = !CalleeTy ? 0 : dyn_cast<FunctionType>(CalleeTy->getElementType()); @@ -1771,13 +1987,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || Record.size() < OpNum+FTy->getNumParams()) return Error("Invalid INVOKE record"); - + SmallVector<Value*, 16> Ops; for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); if (Ops.back() == 0) return Error("Invalid INVOKE record"); } - + if (!FTy->isVarArg()) { if (Record.size() != OpNum) return Error("Invalid INVOKE record"); @@ -1790,28 +2006,33 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Ops.push_back(Op); } } - + I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops.begin(), Ops.end()); - cast<InvokeInst>(I)->setCallingConv(CCInfo); + InstructionList.push_back(I); + cast<InvokeInst>(I)->setCallingConv( + static_cast<CallingConv::ID>(CCInfo)); cast<InvokeInst>(I)->setAttributes(PAL); break; } case bitc::FUNC_CODE_INST_UNWIND: // UNWIND - I = new UnwindInst(); + I = new UnwindInst(Context); + InstructionList.push_back(I); break; case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE - I = new UnreachableInst(); + I = new UnreachableInst(Context); + InstructionList.push_back(I); break; case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] if (Record.size() < 1 || ((Record.size()-1)&1)) return Error("Invalid PHI record"); const Type *Ty = getTypeByID(Record[0]); if (!Ty) return Error("Invalid PHI record"); - + PHINode *PN = PHINode::Create(Ty); + InstructionList.push_back(PN); PN->reserveOperandSpace((Record.size()-1)/2); - + for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { Value *V = getFnValueByID(Record[1+i], Ty); BasicBlock *BB = getBasicBlock(Record[2+i]); @@ -1821,16 +2042,17 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { I = PN; break; } - + case bitc::FUNC_CODE_INST_MALLOC: { // MALLOC: [instty, op, align] if (Record.size() < 3) return Error("Invalid MALLOC record"); const PointerType *Ty = dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); - Value *Size = getFnValueByID(Record[1], Type::Int32Ty); + Value *Size = getFnValueByID(Record[1], Type::getInt32Ty(Context)); unsigned Align = Record[2]; if (!Ty || !Size) return Error("Invalid MALLOC record"); I = new MallocInst(Ty->getElementType(), Size, (1 << Align) >> 1); + InstructionList.push_back(I); break; } case bitc::FUNC_CODE_INST_FREE: { // FREE: [op, opty] @@ -1840,6 +2062,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { OpNum != Record.size()) return Error("Invalid FREE record"); I = new FreeInst(Op); + InstructionList.push_back(I); break; } case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, op, align] @@ -1847,10 +2070,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { return Error("Invalid ALLOCA record"); const PointerType *Ty = dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); - Value *Size = getFnValueByID(Record[1], Type::Int32Ty); + Value *Size = getFnValueByID(Record[1], Type::getInt32Ty(Context)); unsigned Align = Record[2]; if (!Ty || !Size) return Error("Invalid ALLOCA record"); I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); + InstructionList.push_back(I); break; } case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] @@ -1859,20 +2083,22 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) return Error("Invalid LOAD record"); - + I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); + InstructionList.push_back(I); break; } case bitc::FUNC_CODE_INST_STORE2: { // STORE2:[ptrty, ptr, val, align, vol] unsigned OpNum = 0; Value *Val, *Ptr; if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || - getValue(Record, OpNum, + getValue(Record, OpNum, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+2 != Record.size()) return Error("Invalid STORE record"); - + I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); + InstructionList.push_back(I); break; } case bitc::FUNC_CODE_INST_STORE: { // STORE:[val, valty, ptr, align, vol] @@ -1880,32 +2106,34 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Val, *Ptr; if (getValueTypePair(Record, OpNum, NextValueNo, Val) || - getValue(Record, OpNum, PointerType::getUnqual(Val->getType()), Ptr)|| + getValue(Record, OpNum, + PointerType::getUnqual(Val->getType()), Ptr)|| OpNum+2 != Record.size()) return Error("Invalid STORE record"); - + I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); + InstructionList.push_back(I); break; } case bitc::FUNC_CODE_INST_CALL: { // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] if (Record.size() < 3) return Error("Invalid CALL record"); - + AttrListPtr PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; - + unsigned OpNum = 2; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) return Error("Invalid CALL record"); - + const PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); const FunctionType *FTy = 0; if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); if (!FTy || Record.size() < FTy->getNumParams()+OpNum) return Error("Invalid CALL record"); - + SmallVector<Value*, 16> Args; // Read the fixed params. for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { @@ -1915,7 +2143,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); if (Args.back() == 0) return Error("Invalid CALL record"); } - + // Read type/value pairs for varargs params. if (!FTy->isVarArg()) { if (OpNum != Record.size()) @@ -1928,9 +2156,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Args.push_back(Op); } } - + I = CallInst::Create(Callee, Args.begin(), Args.end()); - cast<CallInst>(I)->setCallingConv(CCInfo>>1); + InstructionList.push_back(I); + cast<CallInst>(I)->setCallingConv( + static_cast<CallingConv::ID>(CCInfo>>1)); cast<CallInst>(I)->setTailCall(CCInfo & 1); cast<CallInst>(I)->setAttributes(PAL); break; @@ -1944,6 +2174,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (!OpTy || !Op || !ResTy) return Error("Invalid VAARG record"); I = new VAArgInst(Op, ResTy); + InstructionList.push_back(I); break; } } @@ -1955,18 +2186,18 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { return Error("Invalid instruction with no BB"); } CurBB->getInstList().push_back(I); - + // If this was a terminator instruction, move to the next block. if (isa<TerminatorInst>(I)) { ++CurBBNo; CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; } - + // Non-void values get registered in the value table for future use. - if (I && I->getType() != Type::VoidTy) + if (I && I->getType() != Type::getVoidTy(Context)) ValueList.AssignValue(I, NextValueNo++); } - + // Check the function list for unresolved values. if (Argument *A = dyn_cast<Argument>(ValueList.back())) { if (A->getParent() == 0) { @@ -1980,11 +2211,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { return Error("Never resolved value found in function!"); } } - + // Trim the value list down to the size it was before we parsed this function. ValueList.shrinkTo(ModuleValueListSize); std::vector<BasicBlock*>().swap(FunctionBBs); - + return false; } @@ -1996,16 +2227,16 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) { // If it already is material, ignore the request. if (!F->hasNotBeenReadFromBitcode()) return false; - - DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII = + + DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII = DeferredFunctionInfo.find(F); assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); - + // Move the bit stream to the saved position of the deferred function body and // restore the real linkage type for the function. Stream.JumpToBit(DFII->second.first); F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second); - + if (ParseFunctionBody(F)) { if (ErrInfo) *ErrInfo = ErrorString; return true; @@ -2022,7 +2253,7 @@ bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) { } } } - + return false; } @@ -2030,9 +2261,9 @@ void BitcodeReader::dematerializeFunction(Function *F) { // If this function isn't materialized, or if it is a proto, this is a noop. if (F->hasNotBeenReadFromBitcode() || F->isDeclaration()) return; - + assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); - + // Just forget the function body, we can remat it later. F->deleteBody(); F->setLinkage(GlobalValue::GhostLinkage); @@ -2048,9 +2279,9 @@ Module *BitcodeReader::materializeModule(std::string *ErrInfo) { materializeFunction(F, ErrInfo)) return 0; - // Upgrade any intrinsic calls that slipped through (should not happen!) and - // delete the old functions to clean up. We can't do this unless the entire - // module is materialized because there could always be another function body + // Upgrade any intrinsic calls that slipped through (should not happen!) and + // delete the old functions to clean up. We can't do this unless the entire + // module is materialized because there could always be another function body // with calls to the old function. for (std::vector<std::pair<Function*, Function*> >::iterator I = UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { @@ -2066,7 +2297,10 @@ Module *BitcodeReader::materializeModule(std::string *ErrInfo) { } } std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); - + + // Check debug info intrinsics. + CheckDebugInfoIntrinsics(TheModule); + return TheModule; } @@ -2096,7 +2330,7 @@ ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer, if (R->ParseBitcode()) { if (ErrMsg) *ErrMsg = R->getErrorString(); - + // Don't let the BitcodeReader dtor delete 'Buffer'. R->releaseMemoryBuffer(); delete R; @@ -2107,25 +2341,25 @@ ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer, /// 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, +Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, std::string *ErrMsg){ BitcodeReader *R; - R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, Context, + R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, Context, ErrMsg)); if (!R) return 0; - + // Read in the entire module. Module *M = R->materializeModule(ErrMsg); // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether // there was an error. R->releaseMemoryBuffer(); - + // If there was no error, tell ModuleProvider not to delete it when its dtor // is run. if (M) M = R->releaseModule(ErrMsg); - + delete R; return M; } diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h index 662631b..eefc7bd 100644 --- a/lib/Bitcode/Reader/BitcodeReader.h +++ b/lib/Bitcode/Reader/BitcodeReader.h @@ -44,8 +44,9 @@ class BitcodeReaderValueList { /// number that holds the resolved value. typedef std::vector<std::pair<Constant*, unsigned> > ResolveConstantsTy; ResolveConstantsTy ResolveConstants; + LLVMContext& Context; public: - BitcodeReaderValueList() {} + BitcodeReaderValueList(LLVMContext& C) : Context(C) {} ~BitcodeReaderValueList() { assert(ResolveConstants.empty() && "Constants not resolved?"); } @@ -85,6 +86,41 @@ public: void ResolveConstantForwardRefs(); }; + +//===----------------------------------------------------------------------===// +// BitcodeReaderMDValueList Class +//===----------------------------------------------------------------------===// + +class BitcodeReaderMDValueList { + std::vector<WeakVH> MDValuePtrs; + + LLVMContext& Context; +public: + BitcodeReaderMDValueList(LLVMContext& C) : Context(C) {} + + // vector compatibility methods + unsigned size() const { return MDValuePtrs.size(); } + void resize(unsigned N) { MDValuePtrs.resize(N); } + void push_back(Value *V) { MDValuePtrs.push_back(V); } + void clear() { MDValuePtrs.clear(); } + Value *back() const { return MDValuePtrs.back(); } + void pop_back() { MDValuePtrs.pop_back(); } + bool empty() const { return MDValuePtrs.empty(); } + + Value *operator[](unsigned i) const { + assert(i < MDValuePtrs.size()); + return MDValuePtrs[i]; + } + + void shrinkTo(unsigned N) { + assert(N <= size() && "Invalid shrinkTo request!"); + MDValuePtrs.resize(N); + } + + Value *getValueFwdRef(unsigned Idx); + void AssignValue(Value *V, unsigned Idx); +}; + class BitcodeReader : public ModuleProvider { LLVMContext& Context; MemoryBuffer *Buffer; @@ -95,6 +131,9 @@ class BitcodeReader : public ModuleProvider { std::vector<PATypeHolder> TypeList; BitcodeReaderValueList ValueList; + BitcodeReaderMDValueList MDValueList; + SmallVector<Instruction *, 64> InstructionList; + std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits; std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits; @@ -126,7 +165,7 @@ class BitcodeReader : public ModuleProvider { DenseMap<Function*, std::pair<uint64_t, unsigned> > DeferredFunctionInfo; public: explicit BitcodeReader(MemoryBuffer *buffer, LLVMContext& C) - : Context(C), Buffer(buffer), ErrorString(0) { + : Context(C), Buffer(buffer), ErrorString(0), ValueList(C), MDValueList(C) { HasReversedFunctionsWithBodies = false; } ~BitcodeReader() { @@ -159,7 +198,10 @@ public: private: const Type *getTypeByID(unsigned ID, bool isTypeTable = false); Value *getFnValueByID(unsigned ID, const Type *Ty) { - return ValueList.getValueFwdRef(ID, Ty); + if (Ty == Type::getMetadataTy(Context)) + return MDValueList.getValueFwdRef(ID); + else + return ValueList.getValueFwdRef(ID, Ty); } BasicBlock *getBasicBlock(unsigned ID) const { if (ID >= FunctionBBs.size()) return 0; // Invalid ID @@ -209,6 +251,8 @@ private: bool RememberAndSkipFunctionBody(); bool ParseFunctionBody(Function *F); bool ResolveGlobalAndAliasInits(); + bool ParseMetadata(); + bool ParseMetadataAttachment(); }; } // End llvm namespace diff --git a/lib/Bitcode/Reader/Deserialize.cpp b/lib/Bitcode/Reader/Deserialize.cpp index 06da6ce..67607ef 100644 --- a/lib/Bitcode/Reader/Deserialize.cpp +++ b/lib/Bitcode/Reader/Deserialize.cpp @@ -12,11 +12,7 @@ //===----------------------------------------------------------------------===// #include "llvm/Bitcode/Deserialize.h" - -#ifdef DEBUG_BACKPATCH -#include "llvm/Support/Streams.h" -#endif - +#include "llvm/Support/raw_ostream.h" using namespace llvm; Deserializer::Deserializer(BitstreamReader& stream) @@ -357,7 +353,7 @@ void Deserializer::RegisterPtr(const SerializedPtrID& PtrId, assert (!HasFinalPtr(E) && "Pointer already registered."); #ifdef DEBUG_BACKPATCH - llvm::cerr << "RegisterPtr: " << PtrId << " => " << Ptr << "\n"; + errs() << "RegisterPtr: " << PtrId << " => " << Ptr << "\n"; #endif SetPtr(E,Ptr); @@ -377,8 +373,8 @@ void Deserializer::ReadUIntPtr(uintptr_t& PtrRef, PtrRef = GetFinalPtr(E); #ifdef DEBUG_BACKPATCH - llvm::cerr << "ReadUintPtr: " << PtrId - << " <-- " << (void*) GetFinalPtr(E) << '\n'; + errs() << "ReadUintPtr: " << PtrId + << " <-- " << (void*) GetFinalPtr(E) << '\n'; #endif } else { @@ -386,7 +382,7 @@ void Deserializer::ReadUIntPtr(uintptr_t& PtrRef, "Client forbids backpatching for this pointer."); #ifdef DEBUG_BACKPATCH - llvm::cerr << "ReadUintPtr: " << PtrId << " (NO PTR YET)\n"; + errs() << "ReadUintPtr: " << PtrId << " (NO PTR YET)\n"; #endif // Register backpatch. Check the freelist for a BPNode. diff --git a/lib/Bitcode/Writer/BitWriter.cpp b/lib/Bitcode/Writer/BitWriter.cpp index 8834964..7ed651b 100644 --- a/lib/Bitcode/Writer/BitWriter.cpp +++ b/lib/Bitcode/Writer/BitWriter.cpp @@ -9,43 +9,31 @@ #include "llvm-c/BitWriter.h" #include "llvm/Bitcode/ReaderWriter.h" -#include <fstream> - +#include "llvm/Support/raw_ostream.h" using namespace llvm; /*===-- Operations on modules ---------------------------------------------===*/ int LLVMWriteBitcodeToFile(LLVMModuleRef M, const char *Path) { - std::ofstream OS(Path, std::ios_base::out|std::ios::trunc|std::ios::binary); - - if (!OS.fail()) - WriteBitcodeToFile(unwrap(M), OS); + std::string ErrorInfo; + raw_fd_ostream OS(Path, ErrorInfo, + raw_fd_ostream::F_Binary); - if (OS.fail()) + if (!ErrorInfo.empty()) return -1; + WriteBitcodeToFile(unwrap(M), OS); return 0; } #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR >= 4) #include <ext/stdio_filebuf.h> -// FIXME: Control this with configure? Provide some portable abstraction in -// libSystem? As is, the user will just get a linker error if they use this on -// non-GCC. Some C++ stdlibs even have ofstream::ofstream(int fd). int LLVMWriteBitcodeToFileHandle(LLVMModuleRef M, int FileHandle) { - __gnu_cxx::stdio_filebuf<char> Buffer(FileHandle, std::ios_base::out | - std::ios::trunc | - std::ios::binary); - std::ostream OS(&Buffer); - - if (!OS.fail()) - WriteBitcodeToFile(unwrap(M), OS); - - if (OS.fail()) - return -1; + raw_fd_ostream OS(FileHandle, false); + WriteBitcodeToFile(unwrap(M), OS); return 0; } diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp index 6dcdded..12a1f5e 100644 --- a/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -19,12 +19,13 @@ #include "llvm/DerivedTypes.h" #include "llvm/InlineAsm.h" #include "llvm/Instructions.h" -#include "llvm/MDNode.h" +#include "llvm/Metadata.h" #include "llvm/Module.h" +#include "llvm/Operator.h" #include "llvm/TypeSymbolTable.h" #include "llvm/ValueSymbolTable.h" +#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/MathExtras.h" -#include "llvm/Support/Streams.h" #include "llvm/Support/raw_ostream.h" #include "llvm/System/Program.h" using namespace llvm; @@ -33,22 +34,23 @@ using namespace llvm; /// be kept in sync with the reader, but need to be consistent within this file. enum { CurVersion = 0, - + // VALUE_SYMTAB_BLOCK abbrev id's. VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV, VST_ENTRY_7_ABBREV, VST_ENTRY_6_ABBREV, VST_BBENTRY_6_ABBREV, - + // CONSTANTS_BLOCK abbrev id's. CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV, CONSTANTS_INTEGER_ABBREV, CONSTANTS_CE_CAST_Abbrev, CONSTANTS_NULL_Abbrev, - + // FUNCTION_BLOCK abbrev id's. FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV, FUNCTION_INST_BINOP_ABBREV, + FUNCTION_INST_BINOP_FLAGS_ABBREV, FUNCTION_INST_CAST_ABBREV, FUNCTION_INST_RET_VOID_ABBREV, FUNCTION_INST_RET_VAL_ABBREV, @@ -58,7 +60,7 @@ enum { static unsigned GetEncodedCastOpcode(unsigned Opcode) { switch (Opcode) { - default: assert(0 && "Unknown cast instruction!"); + default: llvm_unreachable("Unknown cast instruction!"); case Instruction::Trunc : return bitc::CAST_TRUNC; case Instruction::ZExt : return bitc::CAST_ZEXT; case Instruction::SExt : return bitc::CAST_SEXT; @@ -76,7 +78,7 @@ static unsigned GetEncodedCastOpcode(unsigned Opcode) { static unsigned GetEncodedBinaryOpcode(unsigned Opcode) { switch (Opcode) { - default: assert(0 && "Unknown binary instruction!"); + default: llvm_unreachable("Unknown binary instruction!"); case Instruction::Add: case Instruction::FAdd: return bitc::BINOP_ADD; case Instruction::Sub: @@ -100,24 +102,24 @@ static unsigned GetEncodedBinaryOpcode(unsigned Opcode) { -static void WriteStringRecord(unsigned Code, const std::string &Str, +static void WriteStringRecord(unsigned Code, const std::string &Str, unsigned AbbrevToUse, BitstreamWriter &Stream) { SmallVector<unsigned, 64> Vals; - + // Code: [strchar x N] for (unsigned i = 0, e = Str.size(); i != e; ++i) Vals.push_back(Str[i]); - + // Emit the finished record. Stream.EmitRecord(Code, Vals, AbbrevToUse); } // Emit information about parameter attributes. -static void WriteAttributeTable(const ValueEnumerator &VE, +static void WriteAttributeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) { const std::vector<AttrListPtr> &Attrs = VE.getAttributes(); if (Attrs.empty()) return; - + Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3); SmallVector<uint64_t, 64> Record; @@ -138,21 +140,21 @@ static void WriteAttributeTable(const ValueEnumerator &VE, Record.push_back(FauxAttr); } - + Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record); Record.clear(); } - + Stream.ExitBlock(); } /// WriteTypeTable - Write out the type table for a module. static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) { const ValueEnumerator::TypeList &TypeList = VE.getTypes(); - + Stream.EnterSubblock(bitc::TYPE_BLOCK_ID, 4 /*count from # abbrevs */); SmallVector<uint64_t, 64> TypeVals; - + // Abbrev for TYPE_CODE_POINTER. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_POINTER)); @@ -160,7 +162,7 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) { Log2_32_Ceil(VE.getTypes().size()+1))); Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 0 unsigned PtrAbbrev = Stream.EmitAbbrev(Abbv); - + // Abbrev for TYPE_CODE_FUNCTION. Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION)); @@ -170,7 +172,7 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(VE.getTypes().size()+1))); unsigned FunctionAbbrev = Stream.EmitAbbrev(Abbv); - + // Abbrev for TYPE_CODE_STRUCT. Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT)); @@ -179,7 +181,7 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(VE.getTypes().size()+1))); unsigned StructAbbrev = Stream.EmitAbbrev(Abbv); - + // Abbrev for TYPE_CODE_ARRAY. Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY)); @@ -187,20 +189,20 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(VE.getTypes().size()+1))); unsigned ArrayAbbrev = Stream.EmitAbbrev(Abbv); - + // Emit an entry count so the reader can reserve space. TypeVals.push_back(TypeList.size()); Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals); TypeVals.clear(); - + // Loop over all of the types, emitting each in turn. for (unsigned i = 0, e = TypeList.size(); i != e; ++i) { const Type *T = TypeList[i].first; int AbbrevToUse = 0; unsigned Code = 0; - + switch (T->getTypeID()) { - default: assert(0 && "Unknown type!"); + default: llvm_unreachable("Unknown type!"); case Type::VoidTyID: Code = bitc::TYPE_CODE_VOID; break; case Type::FloatTyID: Code = bitc::TYPE_CODE_FLOAT; break; case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break; @@ -272,33 +274,34 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) { Stream.EmitRecord(Code, TypeVals, AbbrevToUse); TypeVals.clear(); } - + Stream.ExitBlock(); } static unsigned getEncodedLinkage(const GlobalValue *GV) { switch (GV->getLinkage()) { - default: assert(0 && "Invalid linkage!"); + default: llvm_unreachable("Invalid linkage!"); case GlobalValue::GhostLinkage: // Map ghost linkage onto external. - case GlobalValue::ExternalLinkage: return 0; - case GlobalValue::WeakAnyLinkage: return 1; - case GlobalValue::AppendingLinkage: return 2; - case GlobalValue::InternalLinkage: return 3; - case GlobalValue::LinkOnceAnyLinkage: return 4; - case GlobalValue::DLLImportLinkage: return 5; - case GlobalValue::DLLExportLinkage: return 6; - case GlobalValue::ExternalWeakLinkage: return 7; - case GlobalValue::CommonLinkage: return 8; - case GlobalValue::PrivateLinkage: return 9; - case GlobalValue::WeakODRLinkage: return 10; - case GlobalValue::LinkOnceODRLinkage: return 11; - case GlobalValue::AvailableExternallyLinkage: return 12; + case GlobalValue::ExternalLinkage: return 0; + case GlobalValue::WeakAnyLinkage: return 1; + case GlobalValue::AppendingLinkage: return 2; + case GlobalValue::InternalLinkage: return 3; + case GlobalValue::LinkOnceAnyLinkage: return 4; + case GlobalValue::DLLImportLinkage: return 5; + case GlobalValue::DLLExportLinkage: return 6; + case GlobalValue::ExternalWeakLinkage: return 7; + case GlobalValue::CommonLinkage: return 8; + case GlobalValue::PrivateLinkage: return 9; + case GlobalValue::WeakODRLinkage: return 10; + case GlobalValue::LinkOnceODRLinkage: return 11; + case GlobalValue::AvailableExternallyLinkage: return 12; + case GlobalValue::LinkerPrivateLinkage: return 13; } } static unsigned getEncodedVisibility(const GlobalValue *GV) { switch (GV->getVisibility()) { - default: assert(0 && "Invalid visibility!"); + default: llvm_unreachable("Invalid visibility!"); case GlobalValue::DefaultVisibility: return 0; case GlobalValue::HiddenVisibility: return 1; case GlobalValue::ProtectedVisibility: return 2; @@ -334,7 +337,7 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE, GV != E; ++GV) { MaxAlignment = std::max(MaxAlignment, GV->getAlignment()); MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV->getType())); - + if (!GV->hasSection()) continue; // Give section names unique ID's. unsigned &Entry = SectionMap[GV->getSection()]; @@ -364,10 +367,10 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE, } } } - + // Emit abbrev for globals, now that we know # sections and max alignment. unsigned SimpleGVarAbbrev = 0; - if (!M->global_empty()) { + if (!M->global_empty()) { // Add an abbrev for common globals with no visibility or thread localness. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR)); @@ -391,14 +394,14 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE, // Don't bother emitting vis + thread local. SimpleGVarAbbrev = Stream.EmitAbbrev(Abbv); } - + // Emit the global variable information. SmallVector<unsigned, 64> Vals; for (Module::const_global_iterator GV = M->global_begin(),E = M->global_end(); GV != E; ++GV) { unsigned AbbrevToUse = 0; - // GLOBALVAR: [type, isconst, initid, + // GLOBALVAR: [type, isconst, initid, // linkage, alignment, section, visibility, threadlocal] Vals.push_back(VE.getTypeID(GV->getType())); Vals.push_back(GV->isConstant()); @@ -407,14 +410,14 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE, Vals.push_back(getEncodedLinkage(GV)); Vals.push_back(Log2_32(GV->getAlignment())+1); Vals.push_back(GV->hasSection() ? SectionMap[GV->getSection()] : 0); - if (GV->isThreadLocal() || + if (GV->isThreadLocal() || GV->getVisibility() != GlobalValue::DefaultVisibility) { Vals.push_back(getEncodedVisibility(GV)); Vals.push_back(GV->isThreadLocal()); } else { AbbrevToUse = SimpleGVarAbbrev; } - + Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse); Vals.clear(); } @@ -432,13 +435,13 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE, Vals.push_back(F->hasSection() ? SectionMap[F->getSection()] : 0); Vals.push_back(getEncodedVisibility(F)); Vals.push_back(F->hasGC() ? GCMap[F->getGC()] : 0); - + unsigned AbbrevToUse = 0; Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse); Vals.clear(); } - - + + // Emit the alias information. for (Module::const_alias_iterator AI = M->alias_begin(), E = M->alias_end(); AI != E; ++AI) { @@ -452,20 +455,185 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE, } } +static uint64_t GetOptimizationFlags(const Value *V) { + uint64_t Flags = 0; + + if (const OverflowingBinaryOperator *OBO = + dyn_cast<OverflowingBinaryOperator>(V)) { + if (OBO->hasNoSignedWrap()) + Flags |= 1 << bitc::OBO_NO_SIGNED_WRAP; + if (OBO->hasNoUnsignedWrap()) + Flags |= 1 << bitc::OBO_NO_UNSIGNED_WRAP; + } else if (const SDivOperator *Div = dyn_cast<SDivOperator>(V)) { + if (Div->isExact()) + Flags |= 1 << bitc::SDIV_EXACT; + } + + return Flags; +} + +static void WriteMDNode(const MDNode *N, + const ValueEnumerator &VE, + BitstreamWriter &Stream, + SmallVector<uint64_t, 64> &Record) { + for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) { + if (N->getElement(i)) { + Record.push_back(VE.getTypeID(N->getElement(i)->getType())); + Record.push_back(VE.getValueID(N->getElement(i))); + } else { + Record.push_back(VE.getTypeID(Type::getVoidTy(N->getContext()))); + Record.push_back(0); + } + } + Stream.EmitRecord(bitc::METADATA_NODE, Record, 0); + Record.clear(); +} + +static void WriteModuleMetadata(const ValueEnumerator &VE, + BitstreamWriter &Stream) { + const ValueEnumerator::ValueList &Vals = VE.getMDValues(); + bool StartedMetadataBlock = false; + unsigned MDSAbbrev = 0; + SmallVector<uint64_t, 64> Record; + for (unsigned i = 0, e = Vals.size(); i != e; ++i) { + + if (const MDNode *N = dyn_cast<MDNode>(Vals[i].first)) { + if (!StartedMetadataBlock) { + Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); + StartedMetadataBlock = true; + } + WriteMDNode(N, VE, Stream, Record); + } else if (const MDString *MDS = dyn_cast<MDString>(Vals[i].first)) { + if (!StartedMetadataBlock) { + Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); + + // Abbrev for METADATA_STRING. + BitCodeAbbrev *Abbv = new BitCodeAbbrev(); + Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRING)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); + MDSAbbrev = Stream.EmitAbbrev(Abbv); + StartedMetadataBlock = true; + } + + // Code: [strchar x N] + const char *StrBegin = MDS->begin(); + for (unsigned i = 0, e = MDS->length(); i != e; ++i) + Record.push_back(StrBegin[i]); + + // Emit the finished record. + Stream.EmitRecord(bitc::METADATA_STRING, Record, MDSAbbrev); + Record.clear(); + } else if (const NamedMDNode *NMD = dyn_cast<NamedMDNode>(Vals[i].first)) { + if (!StartedMetadataBlock) { + Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); + StartedMetadataBlock = true; + } + + // Write name. + std::string Str = NMD->getNameStr(); + const char *StrBegin = Str.c_str(); + for (unsigned i = 0, e = Str.length(); i != e; ++i) + Record.push_back(StrBegin[i]); + Stream.EmitRecord(bitc::METADATA_NAME, Record, 0/*TODO*/); + Record.clear(); + + // Write named metadata elements. + for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) { + if (NMD->getElement(i)) + Record.push_back(VE.getValueID(NMD->getElement(i))); + else + Record.push_back(0); + } + Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0); + Record.clear(); + } + } + + if (StartedMetadataBlock) + Stream.ExitBlock(); +} + +static void WriteMetadataAttachment(const Function &F, + const ValueEnumerator &VE, + BitstreamWriter &Stream) { + bool StartedMetadataBlock = false; + SmallVector<uint64_t, 64> Record; + + // Write metadata attachments + // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]] + MetadataContext &TheMetadata = F.getContext().getMetadata(); + for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) + for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); + I != E; ++I) { + const MetadataContext::MDMapTy *P = TheMetadata.getMDs(I); + if (!P) continue; + bool RecordedInstruction = false; + for (MetadataContext::MDMapTy::const_iterator PI = P->begin(), + PE = P->end(); PI != PE; ++PI) { + if (MDNode *ND = dyn_cast_or_null<MDNode>(PI->second)) { + if (RecordedInstruction == false) { + Record.push_back(VE.getInstructionID(I)); + RecordedInstruction = true; + } + Record.push_back(PI->first); + Record.push_back(VE.getValueID(ND)); + } + } + if (!Record.empty()) { + if (!StartedMetadataBlock) { + Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3); + StartedMetadataBlock = true; + } + Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0); + Record.clear(); + } + } + + if (StartedMetadataBlock) + Stream.ExitBlock(); +} + +static void WriteModuleMetadataStore(const Module *M, + const ValueEnumerator &VE, + BitstreamWriter &Stream) { + + bool StartedMetadataBlock = false; + SmallVector<uint64_t, 64> Record; + + // Write metadata kinds + // METADATA_KIND - [n x [id, name]] + MetadataContext &TheMetadata = M->getContext().getMetadata(); + const StringMap<unsigned> *Kinds = TheMetadata.getHandlerNames(); + for (StringMap<unsigned>::const_iterator + I = Kinds->begin(), E = Kinds->end(); I != E; ++I) { + Record.push_back(I->second); + StringRef KName = I->first(); + for (unsigned i = 0, e = KName.size(); i != e; ++i) + Record.push_back(KName[i]); + if (!StartedMetadataBlock) { + Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); + StartedMetadataBlock = true; + } + Stream.EmitRecord(bitc::METADATA_KIND, Record, 0); + Record.clear(); + } + + if (StartedMetadataBlock) + Stream.ExitBlock(); +} static void WriteConstants(unsigned FirstVal, unsigned LastVal, const ValueEnumerator &VE, BitstreamWriter &Stream, bool isGlobal) { if (FirstVal == LastVal) return; - + Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4); unsigned AggregateAbbrev = 0; unsigned String8Abbrev = 0; unsigned CString7Abbrev = 0; unsigned CString6Abbrev = 0; - unsigned MDString8Abbrev = 0; - unsigned MDString6Abbrev = 0; // If this is a constant pool for the module, emit module-specific abbrevs. if (isGlobal) { // Abbrev for CST_CODE_AGGREGATE. @@ -493,21 +661,8 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); CString6Abbrev = Stream.EmitAbbrev(Abbv); + } - // Abbrev for CST_CODE_MDSTRING. - Abbv = new BitCodeAbbrev(); - Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_MDSTRING)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); - MDString8Abbrev = Stream.EmitAbbrev(Abbv); - // Abbrev for CST_CODE_MDSTRING. - Abbv = new BitCodeAbbrev(); - Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_MDSTRING)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); - MDString6Abbrev = Stream.EmitAbbrev(Abbv); - } - SmallVector<uint64_t, 64> Record; const ValueEnumerator::ValueList &Vals = VE.getValues(); @@ -522,16 +677,17 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, CONSTANTS_SETTYPE_ABBREV); Record.clear(); } - + if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { - Record.push_back(unsigned(IA->hasSideEffects())); - + Record.push_back(unsigned(IA->hasSideEffects()) | + unsigned(IA->isMsAsm()) << 1); + // Add the asm string. const std::string &AsmStr = IA->getAsmString(); Record.push_back(AsmStr.size()); for (unsigned i = 0, e = AsmStr.size(); i != e; ++i) Record.push_back(AsmStr[i]); - + // Add the constraint string. const std::string &ConstraintStr = IA->getConstraintString(); Record.push_back(ConstraintStr.size()); @@ -558,11 +714,11 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, Code = bitc::CST_CODE_INTEGER; AbbrevToUse = CONSTANTS_INTEGER_ABBREV; } else { // Wide integers, > 64 bits in size. - // We have an arbitrary precision integer value to write whose - // bit width is > 64. However, in canonical unsigned integer + // We have an arbitrary precision integer value to write whose + // bit width is > 64. However, in canonical unsigned integer // format it is likely that the high bits are going to be zero. // So, we only write the number of active words. - unsigned NWords = IV->getValue().getActiveWords(); + unsigned NWords = IV->getValue().getActiveWords(); const uint64_t *RawWords = IV->getValue().getRawData(); for (unsigned i = 0; i != NWords; ++i) { int64_t V = RawWords[i]; @@ -576,16 +732,16 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { Code = bitc::CST_CODE_FLOAT; const Type *Ty = CFP->getType(); - if (Ty == Type::FloatTy || Ty == Type::DoubleTy) { + if (Ty->isFloatTy() || Ty->isDoubleTy()) { Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue()); - } else if (Ty == Type::X86_FP80Ty) { + } else if (Ty->isX86_FP80Ty()) { // api needed to prevent premature destruction // bits are not in the same order as a normal i80 APInt, compensate. APInt api = CFP->getValueAPF().bitcastToAPInt(); const uint64_t *p = api.getRawData(); Record.push_back((p[1] << 48) | (p[0] >> 16)); Record.push_back(p[0] & 0xffffLL); - } else if (Ty == Type::FP128Ty || Ty == Type::PPC_FP128Ty) { + } else if (Ty->isFP128Ty() || Ty->isPPC_FP128Ty()) { APInt api = CFP->getValueAPF().bitcastToAPInt(); const uint64_t *p = api.getRawData(); Record.push_back(p[0]); @@ -610,10 +766,10 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, unsigned char V = cast<ConstantInt>(C->getOperand(i))->getZExtValue(); Record.push_back(V); isCStr7 &= (V & 128) == 0; - if (isCStrChar6) + if (isCStrChar6) isCStrChar6 = BitCodeAbbrevOp::isChar6(V); } - + if (isCStrChar6) AbbrevToUse = CString6Abbrev; else if (isCStr7) @@ -639,10 +795,15 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, Record.push_back(GetEncodedBinaryOpcode(CE->getOpcode())); Record.push_back(VE.getValueID(C->getOperand(0))); Record.push_back(VE.getValueID(C->getOperand(1))); + uint64_t Flags = GetOptimizationFlags(CE); + if (Flags != 0) + Record.push_back(Flags); } break; case Instruction::GetElementPtr: Code = bitc::CST_CODE_CE_GEP; + if (cast<GEPOperator>(C)->isInBounds()) + Code = bitc::CST_CODE_CE_INBOUNDS_GEP; for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) { Record.push_back(VE.getTypeID(C->getOperand(i)->getType())); Record.push_back(VE.getValueID(C->getOperand(i))); @@ -683,45 +844,15 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, break; case Instruction::ICmp: case Instruction::FCmp: - case Instruction::VICmp: - case Instruction::VFCmp: - if (isa<VectorType>(C->getOperand(0)->getType()) - && (CE->getOpcode() == Instruction::ICmp - || CE->getOpcode() == Instruction::FCmp)) { - // compare returning vector of Int1Ty - assert(0 && "Unsupported constant!"); - } else { - Code = bitc::CST_CODE_CE_CMP; - } + Code = bitc::CST_CODE_CE_CMP; Record.push_back(VE.getTypeID(C->getOperand(0)->getType())); Record.push_back(VE.getValueID(C->getOperand(0))); Record.push_back(VE.getValueID(C->getOperand(1))); Record.push_back(CE->getPredicate()); break; } - } else if (const MDString *S = dyn_cast<MDString>(C)) { - Code = bitc::CST_CODE_MDSTRING; - AbbrevToUse = MDString6Abbrev; - for (unsigned i = 0, e = S->size(); i != e; ++i) { - char V = S->begin()[i]; - Record.push_back(V); - - if (!BitCodeAbbrevOp::isChar6(V)) - AbbrevToUse = MDString8Abbrev; - } - } else if (const MDNode *N = dyn_cast<MDNode>(C)) { - Code = bitc::CST_CODE_MDNODE; - for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) { - if (N->getElement(i)) { - Record.push_back(VE.getTypeID(N->getElement(i)->getType())); - Record.push_back(VE.getValueID(N->getElement(i))); - } else { - Record.push_back(VE.getTypeID(Type::VoidTy)); - Record.push_back(0); - } - } } else { - assert(0 && "Unknown constant!"); + llvm_unreachable("Unknown constant!"); } Stream.EmitRecord(Code, Record, AbbrevToUse); Record.clear(); @@ -733,7 +864,7 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, static void WriteModuleConstants(const ValueEnumerator &VE, BitstreamWriter &Stream) { const ValueEnumerator::ValueList &Vals = VE.getValues(); - + // Find the first constant to emit, which is the first non-globalvalue value. // We know globalvalues have been emitted by WriteModuleInfo. for (unsigned i = 0, e = Vals.size(); i != e; ++i) { @@ -753,7 +884,7 @@ static void WriteModuleConstants(const ValueEnumerator &VE, /// instruction ID, then it is a forward reference, and it also includes the /// type ID. static bool PushValueAndType(const Value *V, unsigned InstID, - SmallVector<unsigned, 64> &Vals, + SmallVector<unsigned, 64> &Vals, ValueEnumerator &VE) { unsigned ValID = VE.getValueID(V); Vals.push_back(ValID); @@ -770,6 +901,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, SmallVector<unsigned, 64> &Vals) { unsigned Code = 0; unsigned AbbrevToUse = 0; + VE.setInstructionID(&I); switch (I.getOpcode()) { default: if (Instruction::isCast(I.getOpcode())) { @@ -785,11 +917,19 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, AbbrevToUse = FUNCTION_INST_BINOP_ABBREV; Vals.push_back(VE.getValueID(I.getOperand(1))); Vals.push_back(GetEncodedBinaryOpcode(I.getOpcode())); + uint64_t Flags = GetOptimizationFlags(&I); + if (Flags != 0) { + if (AbbrevToUse == FUNCTION_INST_BINOP_ABBREV) + AbbrevToUse = FUNCTION_INST_BINOP_FLAGS_ABBREV; + Vals.push_back(Flags); + } } break; case Instruction::GetElementPtr: Code = bitc::FUNC_CODE_INST_GEP; + if (cast<GEPOperator>(&I)->isInBounds()) + Code = bitc::FUNC_CODE_INST_INBOUNDS_GEP; for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) PushValueAndType(I.getOperand(i), InstID, Vals, VE); break; @@ -835,21 +975,14 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, break; case Instruction::ICmp: case Instruction::FCmp: - case Instruction::VICmp: - case Instruction::VFCmp: - if (I.getOpcode() == Instruction::ICmp - || I.getOpcode() == Instruction::FCmp) { - // compare returning Int1Ty or vector of Int1Ty - Code = bitc::FUNC_CODE_INST_CMP2; - } else { - Code = bitc::FUNC_CODE_INST_CMP; - } + // compare returning Int1Ty or vector of Int1Ty + Code = bitc::FUNC_CODE_INST_CMP2; PushValueAndType(I.getOperand(0), InstID, Vals, VE); Vals.push_back(VE.getValueID(I.getOperand(1))); Vals.push_back(cast<CmpInst>(I).getPredicate()); break; - case Instruction::Ret: + case Instruction::Ret: { Code = bitc::FUNC_CODE_INST_RET; unsigned NumOperands = I.getNumOperands(); @@ -887,13 +1020,13 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, const PointerType *PTy = cast<PointerType>(Callee->getType()); const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); Code = bitc::FUNC_CODE_INST_INVOKE; - + Vals.push_back(VE.getAttributeID(II->getAttributes())); Vals.push_back(II->getCallingConv()); Vals.push_back(VE.getValueID(II->getNormalDest())); Vals.push_back(VE.getValueID(II->getUnwindDest())); PushValueAndType(Callee, InstID, Vals, VE); - + // Emit value #'s for the fixed parameters. for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) Vals.push_back(VE.getValueID(I.getOperand(i+3))); // fixed param. @@ -913,38 +1046,38 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, Code = bitc::FUNC_CODE_INST_UNREACHABLE; AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV; break; - + case Instruction::PHI: Code = bitc::FUNC_CODE_INST_PHI; Vals.push_back(VE.getTypeID(I.getType())); for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) Vals.push_back(VE.getValueID(I.getOperand(i))); break; - + case Instruction::Malloc: Code = bitc::FUNC_CODE_INST_MALLOC; Vals.push_back(VE.getTypeID(I.getType())); Vals.push_back(VE.getValueID(I.getOperand(0))); // size. Vals.push_back(Log2_32(cast<MallocInst>(I).getAlignment())+1); break; - + case Instruction::Free: Code = bitc::FUNC_CODE_INST_FREE; PushValueAndType(I.getOperand(0), InstID, Vals, VE); break; - + case Instruction::Alloca: Code = bitc::FUNC_CODE_INST_ALLOCA; Vals.push_back(VE.getTypeID(I.getType())); Vals.push_back(VE.getValueID(I.getOperand(0))); // size. Vals.push_back(Log2_32(cast<AllocaInst>(I).getAlignment())+1); break; - + case Instruction::Load: Code = bitc::FUNC_CODE_INST_LOAD; if (!PushValueAndType(I.getOperand(0), InstID, Vals, VE)) // ptr AbbrevToUse = FUNCTION_INST_LOAD_ABBREV; - + Vals.push_back(Log2_32(cast<LoadInst>(I).getAlignment())+1); Vals.push_back(cast<LoadInst>(I).isVolatile()); break; @@ -960,16 +1093,16 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); Code = bitc::FUNC_CODE_INST_CALL; - + const CallInst *CI = cast<CallInst>(&I); Vals.push_back(VE.getAttributeID(CI->getAttributes())); Vals.push_back((CI->getCallingConv() << 1) | unsigned(CI->isTailCall())); PushValueAndType(CI->getOperand(0), InstID, Vals, VE); // Callee - + // Emit value #'s for the fixed parameters. for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) Vals.push_back(VE.getValueID(I.getOperand(i+1))); // fixed param. - + // Emit type/value pairs for varargs params. if (FTy->isVarArg()) { unsigned NumVarargs = I.getNumOperands()-1-FTy->getNumParams(); @@ -986,7 +1119,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, Vals.push_back(VE.getTypeID(I.getType())); // restype. break; } - + Stream.EmitRecord(Code, Vals, AbbrevToUse); Vals.clear(); } @@ -1001,27 +1134,27 @@ static void WriteValueSymbolTable(const ValueSymbolTable &VST, // FIXME: Set up the abbrev, we know how many values there are! // FIXME: We know if the type names can use 7-bit ascii. SmallVector<unsigned, 64> NameVals; - + for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end(); SI != SE; ++SI) { - + const ValueName &Name = *SI; - + // Figure out the encoding to use for the name. bool is7Bit = true; bool isChar6 = true; for (const char *C = Name.getKeyData(), *E = C+Name.getKeyLength(); C != E; ++C) { - if (isChar6) + if (isChar6) isChar6 = BitCodeAbbrevOp::isChar6(*C); if ((unsigned char)*C & 128) { is7Bit = false; break; // don't bother scanning the rest. } } - + unsigned AbbrevToUse = VST_ENTRY_8_ABBREV; - + // VST_ENTRY: [valueid, namechar x N] // VST_BBENTRY: [bbid, namechar x N] unsigned Code; @@ -1036,12 +1169,12 @@ static void WriteValueSymbolTable(const ValueSymbolTable &VST, else if (is7Bit) AbbrevToUse = VST_ENTRY_7_ABBREV; } - + NameVals.push_back(VE.getValueID(SI->getValue())); for (const char *P = Name.getKeyData(), *E = Name.getKeyData()+Name.getKeyLength(); P != E; ++P) NameVals.push_back((unsigned char)*P); - + // Emit the finished record. Stream.EmitRecord(Code, NameVals, AbbrevToUse); NameVals.clear(); @@ -1050,39 +1183,40 @@ static void WriteValueSymbolTable(const ValueSymbolTable &VST, } /// WriteFunction - Emit a function body to the module stream. -static void WriteFunction(const Function &F, ValueEnumerator &VE, +static void WriteFunction(const Function &F, ValueEnumerator &VE, BitstreamWriter &Stream) { Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 4); VE.incorporateFunction(F); SmallVector<unsigned, 64> Vals; - + // Emit the number of basic blocks, so the reader can create them ahead of // time. Vals.push_back(VE.getBasicBlocks().size()); Stream.EmitRecord(bitc::FUNC_CODE_DECLAREBLOCKS, Vals); Vals.clear(); - + // If there are function-local constants, emit them now. unsigned CstStart, CstEnd; VE.getFunctionConstantRange(CstStart, CstEnd); WriteConstants(CstStart, CstEnd, VE, Stream, false); - - // Keep a running idea of what the instruction ID is. + + // Keep a running idea of what the instruction ID is. unsigned InstID = CstEnd; - + // Finally, emit all the instructions, in order. for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) { WriteInstruction(*I, InstID, VE, Stream, Vals); - if (I->getType() != Type::VoidTy) + if (I->getType() != Type::getVoidTy(F.getContext())) ++InstID; } - + // Emit names for all the instructions etc. WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream); - + + WriteMetadataAttachment(F, VE, Stream); VE.purgeFunction(); Stream.ExitBlock(); } @@ -1092,9 +1226,9 @@ static void WriteTypeSymbolTable(const TypeSymbolTable &TST, const ValueEnumerator &VE, BitstreamWriter &Stream) { if (TST.empty()) return; - + Stream.EnterSubblock(bitc::TYPE_SYMTAB_BLOCK_ID, 3); - + // 7-bit fixed width VST_CODE_ENTRY strings. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY)); @@ -1103,14 +1237,14 @@ static void WriteTypeSymbolTable(const TypeSymbolTable &TST, Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); unsigned V7Abbrev = Stream.EmitAbbrev(Abbv); - + SmallVector<unsigned, 64> NameVals; - - for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); + + for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); TI != TE; ++TI) { // TST_ENTRY: [typeid, namechar x N] NameVals.push_back(VE.getTypeID(TI->second)); - + const std::string &Str = TI->first; bool is7Bit = true; for (unsigned i = 0, e = Str.size(); i != e; ++i) { @@ -1118,12 +1252,12 @@ static void WriteTypeSymbolTable(const TypeSymbolTable &TST, if (Str[i] & 128) is7Bit = false; } - + // Emit the finished record. Stream.EmitRecord(bitc::VST_CODE_ENTRY, NameVals, is7Bit ? V7Abbrev : 0); NameVals.clear(); } - + Stream.ExitBlock(); } @@ -1133,18 +1267,18 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { // instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK. Other // blocks can defined their abbrevs inline. Stream.EnterBlockInfoBlock(2); - + { // 8-bit fixed-width VST_ENTRY/VST_BBENTRY strings. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); - if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, + if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) != VST_ENTRY_8_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } - + { // 7-bit fixed width VST_ENTRY strings. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY)); @@ -1153,7 +1287,7 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) != VST_ENTRY_7_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } { // 6-bit char6 VST_ENTRY strings. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); @@ -1163,7 +1297,7 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) != VST_ENTRY_6_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } { // 6-bit char6 VST_BBENTRY strings. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); @@ -1173,11 +1307,11 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) != VST_BBENTRY_6_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } - - - + + + { // SETTYPE abbrev for CONSTANTS_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_SETTYPE)); @@ -1185,18 +1319,18 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Log2_32_Ceil(VE.getTypes().size()+1))); if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) != CONSTANTS_SETTYPE_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } - + { // INTEGER abbrev for CONSTANTS_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_INTEGER)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) != CONSTANTS_INTEGER_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } - + { // CE_CAST abbrev for CONSTANTS_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CE_CAST)); @@ -1207,18 +1341,18 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) != CONSTANTS_CE_CAST_Abbrev) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } { // NULL abbrev for CONSTANTS_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_NULL)); if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) != CONSTANTS_NULL_Abbrev) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } - + // FIXME: This should only use space for first class types! - + { // INST_LOAD abbrev for FUNCTION_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_LOAD)); @@ -1227,7 +1361,7 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // volatile if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) != FUNCTION_INST_LOAD_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } { // INST_BINOP abbrev for FUNCTION_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); @@ -1237,7 +1371,18 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) != FUNCTION_INST_BINOP_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); + } + { // INST_BINOP_FLAGS abbrev for FUNCTION_BLOCK. + BitCodeAbbrev *Abbv = new BitCodeAbbrev(); + Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // RHS + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); // flags + if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, + Abbv) != FUNCTION_INST_BINOP_FLAGS_ABBREV) + llvm_unreachable("Unexpected abbrev ordering!"); } { // INST_CAST abbrev for FUNCTION_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); @@ -1248,15 +1393,15 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) != FUNCTION_INST_CAST_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } - + { // INST_RET abbrev for FUNCTION_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET)); if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) != FUNCTION_INST_RET_VOID_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } { // INST_RET abbrev for FUNCTION_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); @@ -1264,16 +1409,16 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ValID if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) != FUNCTION_INST_RET_VAL_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } { // INST_UNREACHABLE abbrev for FUNCTION_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNREACHABLE)); if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) != FUNCTION_INST_UNREACHABLE_ABBREV) - assert(0 && "Unexpected abbrev ordering!"); + llvm_unreachable("Unexpected abbrev ordering!"); } - + Stream.ExitBlock(); } @@ -1281,44 +1426,50 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { /// WriteModule - Emit the specified module to the bitstream. static void WriteModule(const Module *M, BitstreamWriter &Stream) { Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3); - + // Emit the version number if it is non-zero. if (CurVersion) { SmallVector<unsigned, 1> Vals; Vals.push_back(CurVersion); Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals); } - + // Analyze the module, enumerating globals, functions, etc. ValueEnumerator VE(M); // Emit blockinfo, which defines the standard abbreviations etc. WriteBlockInfo(VE, Stream); - + // Emit information about parameter attributes. WriteAttributeTable(VE, Stream); - + // Emit information describing all of the types in the module. WriteTypeTable(VE, Stream); - + // Emit top-level description of module, including target triple, inline asm, // descriptors for global variables, and function prototype info. WriteModuleInfo(M, VE, Stream); - + // Emit constants. WriteModuleConstants(VE, Stream); - + + // Emit metadata. + WriteModuleMetadata(VE, Stream); + // Emit function bodies. for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) if (!I->isDeclaration()) WriteFunction(*I, VE, Stream); - + + // Emit metadata. + WriteModuleMetadataStore(M, VE, Stream); + // Emit the type symbol table information. WriteTypeSymbolTable(M->getTypeSymbolTable(), VE, Stream); - + // Emit names for globals/functions etc. WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream); - + Stream.ExitBlock(); } @@ -1326,7 +1477,7 @@ static void WriteModule(const Module *M, BitstreamWriter &Stream) { /// header and trailer to make it compatible with the system archiver. To do /// this we emit the following header, and then emit a trailer that pads the /// file out to be a multiple of 16 bytes. -/// +/// /// struct bc_header { /// uint32_t Magic; // 0x0B17C0DE /// uint32_t Version; // Version, currently always 0. @@ -1343,7 +1494,7 @@ enum { static void EmitDarwinBCHeader(BitstreamWriter &Stream, const std::string &TT) { unsigned CPUType = ~0U; - + // Match x86_64-*, i[3-9]86-*, powerpc-*, powerpc64-*. The CPUType is a // magic number from /usr/include/mach/machine.h. It is ok to reproduce the // specific constants here because they are implicitly part of the Darwin ABI. @@ -1352,7 +1503,7 @@ static void EmitDarwinBCHeader(BitstreamWriter &Stream, DARWIN_CPU_TYPE_X86 = 7, DARWIN_CPU_TYPE_POWERPC = 18 }; - + if (TT.find("x86_64-") == 0) CPUType = DARWIN_CPU_TYPE_X86 | DARWIN_CPU_ARCH_ABI64; else if (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' && @@ -1362,10 +1513,10 @@ static void EmitDarwinBCHeader(BitstreamWriter &Stream, CPUType = DARWIN_CPU_TYPE_POWERPC; else if (TT.find("powerpc64-") == 0) CPUType = DARWIN_CPU_TYPE_POWERPC | DARWIN_CPU_ARCH_ABI64; - + // Traditional Bitcode starts after header. unsigned BCOffset = DarwinBCHeaderSize; - + Stream.Emit(0x0B17C0DE, 32); Stream.Emit(0 , 32); // Version. Stream.Emit(BCOffset , 32); @@ -1378,7 +1529,7 @@ static void EmitDarwinBCHeader(BitstreamWriter &Stream, static void EmitDarwinBCTrailer(BitstreamWriter &Stream, unsigned BufferSize) { // Update the size field in the header. Stream.BackpatchWord(DarwinBCSizeFieldOffset, BufferSize-DarwinBCHeaderSize); - + // If the file is not a multiple of 16 bytes, insert dummy padding. while (BufferSize & 15) { Stream.Emit(0, 8); @@ -1389,31 +1540,21 @@ static void EmitDarwinBCTrailer(BitstreamWriter &Stream, unsigned BufferSize) { /// WriteBitcodeToFile - Write the specified module to the specified output /// stream. -void llvm::WriteBitcodeToFile(const Module *M, std::ostream &Out) { - raw_os_ostream RawOut(Out); - // If writing to stdout, set binary mode. - if (llvm::cout == Out) - sys::Program::ChangeStdoutToBinary(); - WriteBitcodeToFile(M, RawOut); -} - -/// WriteBitcodeToFile - Write the specified module to the specified output -/// stream. void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out) { std::vector<unsigned char> Buffer; BitstreamWriter Stream(Buffer); - + Buffer.reserve(256*1024); WriteBitcodeToStream( M, Stream ); - + // If writing to stdout, set binary mode. if (&llvm::outs() == &Out) sys::Program::ChangeStdoutToBinary(); // Write the generated bitstream to "Out". Out.write((char*)&Buffer.front(), Buffer.size()); - + // Make sure it hits disk now. Out.flush(); } @@ -1425,7 +1566,7 @@ void llvm::WriteBitcodeToStream(const Module *M, BitstreamWriter &Stream) { bool isDarwin = M->getTargetTriple().find("-darwin") != std::string::npos; if (isDarwin) EmitDarwinBCHeader(Stream, M->getTargetTriple()); - + // Emit the file header. Stream.Emit((unsigned)'B', 8); Stream.Emit((unsigned)'C', 8); diff --git a/lib/Bitcode/Writer/BitcodeWriterPass.cpp b/lib/Bitcode/Writer/BitcodeWriterPass.cpp index 209cf09..3a0d3ce 100644 --- a/lib/Bitcode/Writer/BitcodeWriterPass.cpp +++ b/lib/Bitcode/Writer/BitcodeWriterPass.cpp @@ -17,24 +17,16 @@ using namespace llvm; namespace { class WriteBitcodePass : public ModulePass { - // FIXME: Kill off std::ostream - std::ostream *Out; - raw_ostream *RawOut; // raw_ostream to print on + raw_ostream &OS; // raw_ostream to print on public: static char ID; // Pass identification, replacement for typeid - explicit WriteBitcodePass(std::ostream &o) - : ModulePass(&ID), Out(&o), RawOut(0) {} explicit WriteBitcodePass(raw_ostream &o) - : ModulePass(&ID), Out(0), RawOut(&o) {} + : ModulePass(&ID), OS(o) {} const char *getPassName() const { return "Bitcode Writer"; } bool runOnModule(Module &M) { - if (Out) { - WriteBitcodeToFile(&M, *Out); - } else { - WriteBitcodeToFile(&M, *RawOut); - } + WriteBitcodeToFile(&M, OS); return false; } }; @@ -42,13 +34,6 @@ namespace { char WriteBitcodePass::ID = 0; -/// CreateBitcodeWriterPass - Create and return a pass that writes the module -/// to the specified ostream. -ModulePass *llvm::CreateBitcodeWriterPass(std::ostream &Str) { - return new WriteBitcodePass(Str); -} - - /// createBitcodeWriterPass - Create and return a pass that writes the module /// to the specified ostream. ModulePass *llvm::createBitcodeWriterPass(raw_ostream &Str) { diff --git a/lib/Bitcode/Writer/Serialize.cpp b/lib/Bitcode/Writer/Serialize.cpp index 79464a6..a6beb17 100644 --- a/lib/Bitcode/Writer/Serialize.cpp +++ b/lib/Bitcode/Writer/Serialize.cpp @@ -12,11 +12,8 @@ //===----------------------------------------------------------------------===// #include "llvm/Bitcode/Serialize.h" -#include "string.h" - -#ifdef DEBUG_BACKPATCH -#include "llvm/Support/Streams.h" -#endif +#include "llvm/Support/raw_ostream.h" +#include <cstring> using namespace llvm; @@ -86,7 +83,7 @@ SerializedPtrID Serializer::getPtrId(const void* ptr) { if (I == PtrMap.end()) { unsigned id = PtrMap.size()+1; #ifdef DEBUG_BACKPATCH - llvm::cerr << "Registered PTR: " << ptr << " => " << id << "\n"; + errs() << "Registered PTR: " << ptr << " => " << id << "\n"; #endif PtrMap[ptr] = id; return id; diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/Writer/ValueEnumerator.cpp index 32b2819..60253ad 100644 --- a/lib/Bitcode/Writer/ValueEnumerator.cpp +++ b/lib/Bitcode/Writer/ValueEnumerator.cpp @@ -14,7 +14,7 @@ #include "ValueEnumerator.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" -#include "llvm/MDNode.h" +#include "llvm/Metadata.h" #include "llvm/Module.h" #include "llvm/TypeSymbolTable.h" #include "llvm/ValueSymbolTable.h" @@ -40,6 +40,8 @@ static bool CompareByFrequency(const std::pair<const llvm::Type*, /// ValueEnumerator - Enumerate module-level information. ValueEnumerator::ValueEnumerator(const Module *M) { + InstructionCount = 0; + // Enumerate the global variables. for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I) @@ -55,10 +57,10 @@ ValueEnumerator::ValueEnumerator(const Module *M) { for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); I != E; ++I) EnumerateValue(I); - + // Remember what is the cutoff between globalvalue's and other constants. unsigned FirstConstant = Values.size(); - + // Enumerate the global variable initializers. for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I) @@ -69,24 +71,25 @@ ValueEnumerator::ValueEnumerator(const Module *M) { for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); I != E; ++I) EnumerateValue(I->getAliasee()); - + // Enumerate types used by the type symbol table. EnumerateTypeSymbolTable(M->getTypeSymbolTable()); // Insert constants that are named at module level into the slot pool so that // the module symbol table can refer to them... EnumerateValueSymbolTable(M->getValueSymbolTable()); - + // Enumerate types used by function bodies and argument lists. for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) { - + for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) EnumerateType(I->getType()); - + + MetadataContext &TheMetadata = F->getContext().getMetadata(); for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;++I){ - for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); + for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); OI != E; ++OI) EnumerateOperandType(*OI); EnumerateType(I->getType()); @@ -94,16 +97,24 @@ ValueEnumerator::ValueEnumerator(const Module *M) { EnumerateAttributes(CI->getAttributes()); else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) EnumerateAttributes(II->getAttributes()); + + // Enumerate metadata attached with this instruction. + const MetadataContext::MDMapTy *MDs = TheMetadata.getMDs(I); + if (MDs) + for (MetadataContext::MDMapTy::const_iterator MI = MDs->begin(), + ME = MDs->end(); MI != ME; ++MI) + if (MDNode *MDN = dyn_cast_or_null<MDNode>(MI->second)) + EnumerateMetadata(MDN); } } - + // Optimize constant ordering. OptimizeConstants(FirstConstant, Values.size()); - + // Sort the type table by frequency so that most commonly used types are early // in the table (have low bit-width). std::stable_sort(Types.begin(), Types.end(), CompareByFrequency); - + // Partition the Type ID's so that the single-value types occur before the // aggregate types. This allows the aggregate types to be dropped from the // type table after parsing the global variable initializers. @@ -114,6 +125,28 @@ ValueEnumerator::ValueEnumerator(const Module *M) { TypeMap[Types[i].first] = i+1; } +unsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const { + InstructionMapType::const_iterator I = InstructionMap.find(Inst); + assert (I != InstructionMap.end() && "Instruction is not mapped!"); + return I->second; +} + +void ValueEnumerator::setInstructionID(const Instruction *I) { + InstructionMap[I] = InstructionCount++; +} + +unsigned ValueEnumerator::getValueID(const Value *V) const { + if (isa<MetadataBase>(V)) { + ValueMapType::const_iterator I = MDValueMap.find(V); + assert(I != MDValueMap.end() && "Value not in slotcalculator!"); + return I->second-1; + } + + ValueMapType::const_iterator I = ValueMap.find(V); + assert(I != ValueMap.end() && "Value not in slotcalculator!"); + return I->second-1; +} + // Optimize constant ordering. namespace { struct CstSortPredicate { @@ -123,7 +156,7 @@ namespace { const std::pair<const Value*, unsigned> &RHS) { // Sort by plane. if (LHS.first->getType() != RHS.first->getType()) - return VE.getTypeID(LHS.first->getType()) < + return VE.getTypeID(LHS.first->getType()) < VE.getTypeID(RHS.first->getType()); // Then by frequency. return LHS.second > RHS.second; @@ -134,15 +167,15 @@ namespace { /// OptimizeConstants - Reorder constant pool for denser encoding. void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) { if (CstStart == CstEnd || CstStart+1 == CstEnd) return; - + CstSortPredicate P(*this); std::stable_sort(Values.begin()+CstStart, Values.begin()+CstEnd, P); - + // Ensure that integer constants are at the start of the constant pool. This // is important so that GEP structure indices come before gep constant exprs. std::partition(Values.begin()+CstStart, Values.begin()+CstEnd, isIntegerValue); - + // Rebuild the modified portion of ValueMap. for (; CstStart != CstEnd; ++CstStart) ValueMap[Values[CstStart].first] = CstStart+1; @@ -152,7 +185,7 @@ void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) { /// EnumerateTypeSymbolTable - Insert all of the types in the specified symbol /// table. void ValueEnumerator::EnumerateTypeSymbolTable(const TypeSymbolTable &TST) { - for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); + for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); TI != TE; ++TI) EnumerateType(TI->second); } @@ -160,14 +193,57 @@ void ValueEnumerator::EnumerateTypeSymbolTable(const TypeSymbolTable &TST) { /// EnumerateValueSymbolTable - Insert all of the values in the specified symbol /// table into the values table. void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) { - for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end(); + for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end(); VI != VE; ++VI) EnumerateValue(VI->getValue()); } +void ValueEnumerator::EnumerateMetadata(const MetadataBase *MD) { + // Check to see if it's already in! + unsigned &MDValueID = MDValueMap[MD]; + if (MDValueID) { + // Increment use count. + MDValues[MDValueID-1].second++; + return; + } + + // Enumerate the type of this value. + EnumerateType(MD->getType()); + + if (const MDNode *N = dyn_cast<MDNode>(MD)) { + MDValues.push_back(std::make_pair(MD, 1U)); + MDValueMap[MD] = MDValues.size(); + MDValueID = MDValues.size(); + for (MDNode::const_elem_iterator I = N->elem_begin(), E = N->elem_end(); + I != E; ++I) { + if (*I) + EnumerateValue(*I); + else + EnumerateType(Type::getVoidTy(MD->getContext())); + } + return; + } else if (const NamedMDNode *N = dyn_cast<NamedMDNode>(MD)) { + for(NamedMDNode::const_elem_iterator I = N->elem_begin(), + E = N->elem_end(); I != E; ++I) { + MetadataBase *M = *I; + EnumerateValue(M); + } + MDValues.push_back(std::make_pair(MD, 1U)); + MDValueMap[MD] = Values.size(); + return; + } + + // Add the value. + MDValues.push_back(std::make_pair(MD, 1U)); + MDValueID = MDValues.size(); +} + void ValueEnumerator::EnumerateValue(const Value *V) { - assert(V->getType() != Type::VoidTy && "Can't insert void values!"); - + assert(V->getType() != Type::getVoidTy(V->getContext()) && + "Can't insert void values!"); + if (const MetadataBase *MB = dyn_cast<MetadataBase>(V)) + return EnumerateMetadata(MB); + // Check to see if it's already in! unsigned &ValueID = ValueMap[V]; if (ValueID) { @@ -178,7 +254,7 @@ void ValueEnumerator::EnumerateValue(const Value *V) { // Enumerate the type of this value. EnumerateType(V->getType()); - + if (const Constant *C = dyn_cast<Constant>(V)) { if (isa<GlobalValue>(C)) { // Initializers for globals are handled explicitly elsewhere. @@ -190,7 +266,7 @@ void ValueEnumerator::EnumerateValue(const Value *V) { // If a constant has operands, enumerate them. This makes sure that if a // constant has uses (for example an array of const ints), that they are // inserted also. - + // We prefer to enumerate them with values before we enumerate the user // itself. This makes it more likely that we can avoid forward references // in the reader. We know that there can be no cycles in the constants @@ -198,27 +274,15 @@ void ValueEnumerator::EnumerateValue(const Value *V) { for (User::const_op_iterator I = C->op_begin(), E = C->op_end(); I != E; ++I) EnumerateValue(*I); - + // Finally, add the value. Doing this could make the ValueID reference be // dangling, don't reuse it. Values.push_back(std::make_pair(V, 1U)); ValueMap[V] = Values.size(); return; - } else if (const MDNode *N = dyn_cast<MDNode>(C)) { - for (MDNode::const_elem_iterator I = N->elem_begin(), E = N->elem_end(); - I != E; ++I) { - if (*I) - EnumerateValue(*I); - else - EnumerateType(Type::VoidTy); - } - - Values.push_back(std::make_pair(V, 1U)); - ValueMap[V] = Values.size(); - return; } } - + // Add the value. Values.push_back(std::make_pair(V, 1U)); ValueID = Values.size(); @@ -227,17 +291,17 @@ void ValueEnumerator::EnumerateValue(const Value *V) { void ValueEnumerator::EnumerateType(const Type *Ty) { unsigned &TypeID = TypeMap[Ty]; - + if (TypeID) { // If we've already seen this type, just increase its occurrence count. Types[TypeID-1].second++; return; } - + // First time we saw this type, add it. Types.push_back(std::make_pair(Ty, 1U)); TypeID = Types.size(); - + // Enumerate subtypes. for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end(); I != E; ++I) @@ -259,10 +323,14 @@ void ValueEnumerator::EnumerateOperandType(const Value *V) { EnumerateOperandType(C->getOperand(i)); if (const MDNode *N = dyn_cast<MDNode>(V)) { - for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) - EnumerateOperandType(N->getElement(i)); + for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) { + Value *Elem = N->getElement(i); + if (Elem) + EnumerateOperandType(Elem); + } } - } + } else if (isa<MDString>(V) || isa<MDNode>(V)) + EnumerateValue(V); } void ValueEnumerator::EnumerateAttributes(const AttrListPtr &PAL) { @@ -279,18 +347,18 @@ void ValueEnumerator::EnumerateAttributes(const AttrListPtr &PAL) { void ValueEnumerator::incorporateFunction(const Function &F) { NumModuleValues = Values.size(); - + // Adding function arguments to the value table. for(Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) EnumerateValue(I); FirstFuncConstantID = Values.size(); - + // Add all function-level constants to the value table. for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) - for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); + for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); OI != E; ++OI) { if ((isa<Constant>(*OI) && !isa<GlobalValue>(*OI)) || isa<InlineAsm>(*OI)) @@ -299,20 +367,20 @@ void ValueEnumerator::incorporateFunction(const Function &F) { BasicBlocks.push_back(BB); ValueMap[BB] = BasicBlocks.size(); } - + // Optimize the constant layout. OptimizeConstants(FirstFuncConstantID, Values.size()); - + // Add the function's parameter attributes so they are available for use in // the function's instruction. EnumerateAttributes(F.getAttributes()); FirstInstID = Values.size(); - + // Add all of the instructions. for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) { - if (I->getType() != Type::VoidTy) + if (I->getType() != Type::getVoidTy(F.getContext())) EnumerateValue(I); } } @@ -324,8 +392,7 @@ void ValueEnumerator::purgeFunction() { ValueMap.erase(Values[i].first); for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i) ValueMap.erase(BasicBlocks[i]); - + Values.resize(NumModuleValues); BasicBlocks.clear(); } - diff --git a/lib/Bitcode/Writer/ValueEnumerator.h b/lib/Bitcode/Writer/ValueEnumerator.h index 40eeabb..da63dde 100644 --- a/lib/Bitcode/Writer/ValueEnumerator.h +++ b/lib/Bitcode/Writer/ValueEnumerator.h @@ -22,9 +22,11 @@ namespace llvm { class Type; class Value; +class Instruction; class BasicBlock; class Function; class Module; +class MetadataBase; class AttrListPtr; class TypeSymbolTable; class ValueSymbolTable; @@ -44,11 +46,17 @@ private: typedef DenseMap<const Value*, unsigned> ValueMapType; ValueMapType ValueMap; ValueList Values; + ValueList MDValues; + ValueMapType MDValueMap; typedef DenseMap<void*, unsigned> AttributeMapType; AttributeMapType AttributeMap; std::vector<AttrListPtr> Attributes; + typedef DenseMap<const Instruction*, unsigned> InstructionMapType; + InstructionMapType InstructionMap; + unsigned InstructionCount; + /// BasicBlocks - This contains all the basic blocks for the currently /// incorporated function. Their reverse mapping is stored in ValueMap. std::vector<const BasicBlock*> BasicBlocks; @@ -64,18 +72,17 @@ private: public: ValueEnumerator(const Module *M); - unsigned getValueID(const Value *V) const { - ValueMapType::const_iterator I = ValueMap.find(V); - assert(I != ValueMap.end() && "Value not in slotcalculator!"); - return I->second-1; - } - + unsigned getValueID(const Value *V) const; + unsigned getTypeID(const Type *T) const { TypeMapType::const_iterator I = TypeMap.find(T); assert(I != TypeMap.end() && "Type not in ValueEnumerator!"); return I->second-1; } - + + unsigned getInstructionID(const Instruction *I) const; + void setInstructionID(const Instruction *I); + unsigned getAttributeID(const AttrListPtr &PAL) const { if (PAL.isEmpty()) return 0; // Null maps to zero. AttributeMapType::const_iterator I = AttributeMap.find(PAL.getRawPointer()); @@ -91,6 +98,7 @@ public: } const ValueList &getValues() const { return Values; } + const ValueList &getMDValues() const { return MDValues; } const TypeList &getTypes() const { return Types; } const std::vector<const BasicBlock*> &getBasicBlocks() const { return BasicBlocks; @@ -108,6 +116,7 @@ public: private: void OptimizeConstants(unsigned CstStart, unsigned CstEnd); + void EnumerateMetadata(const MetadataBase *MD); void EnumerateValue(const Value *V); void EnumerateType(const Type *T); void EnumerateOperandType(const Value *V); |
