diff options
Diffstat (limited to 'llvm/lib/Bitcode')
| -rw-r--r-- | llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 412 | ||||
| -rw-r--r-- | llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 274 | ||||
| -rw-r--r-- | llvm/lib/Bitcode/Writer/ValueEnumerator.cpp | 79 |
3 files changed, 382 insertions, 383 deletions
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index 70d2fc5907e..f3ab806271a 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -35,7 +35,7 @@ void BitcodeReader::FreeState() { std::vector<PATypeHolder>().swap(TypeList); ValueList.clear(); MDValueList.clear(); - + std::vector<AttrListPtr>().swap(MAttributes); std::vector<BasicBlock*>().swap(FunctionBBs); std::vector<Function*>().swap(FunctionsWithBodies); @@ -53,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; @@ -145,15 +145,15 @@ namespace { : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 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); }; @@ -171,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)) { @@ -193,7 +193,7 @@ void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { delete PrevVal; } } - + Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, const Type *Ty) { @@ -214,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; @@ -237,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); @@ -275,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); @@ -301,12 +301,12 @@ 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; @@ -318,16 +318,16 @@ void BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 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); @@ -340,12 +340,12 @@ void BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { Value *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { if (Idx >= size()) resize(Idx + 1); - + if (Value *V = MDValuePtrs[Idx]) { assert(V->getType() == Type::getMetadataTy(Context) && "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; @@ -357,7 +357,7 @@ const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) { 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) @@ -372,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(); @@ -388,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(); @@ -396,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)) { @@ -440,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; } @@ -475,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!"); @@ -492,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(); @@ -500,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; @@ -550,10 +550,10 @@ bool BitcodeReader::ParseTypeTable() { case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] if (Record.size() < 1) return Error("Invalid Integer type record"); - + 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"); @@ -572,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; @@ -597,7 +597,7 @@ 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(Context)); @@ -612,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. @@ -633,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) { @@ -645,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(); @@ -653,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)) { @@ -683,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) { @@ -692,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(); @@ -700,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)) { @@ -718,7 +718,7 @@ bool BitcodeReader::ParseValueSymbolTable() { if (ValueID >= ValueList.size()) return Error("Invalid Value ID in VST_ENTRY record"); Value *V = ValueList[ValueID]; - + V->setName(StringRef(ValueName.data(), ValueName.size())); ValueName.clear(); break; @@ -729,7 +729,7 @@ bool BitcodeReader::ParseValueSymbolTable() { BasicBlock *BB = getBasicBlock(Record[0]); if (BB == 0) return Error("Invalid BB ID in VST_BBENTRY record"); - + BB->setName(StringRef(ValueName.data(), ValueName.size())); ValueName.clear(); break; @@ -743,9 +743,9 @@ bool BitcodeReader::ParseMetadata() { 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(); @@ -754,7 +754,7 @@ bool BitcodeReader::ParseMetadata() { return Error("Error at end of PARAMATTR block"); return false; } - + if (Code == bitc::ENTER_SUBBLOCK) { // No known subblocks, always skip them. Stream.ReadSubBlockID(); @@ -762,12 +762,12 @@ bool BitcodeReader::ParseMetadata() { return Error("Malformed block record"); continue; } - + if (Code == bitc::DEFINE_ABBREV) { Stream.ReadAbbrevRecord(); continue; } - + // Read a record. Record.clear(); switch (Stream.ReadRecord(Code, Record)) { @@ -795,7 +795,7 @@ bool BitcodeReader::ParseMetadata() { if (MetadataBase *B = dyn_cast<MetadataBase>(MD)) Elts.push_back(B); } - Value *V = NamedMDNode::Create(Context, Name.str(), Elts.data(), + Value *V = NamedMDNode::Create(Context, Name.str(), Elts.data(), Elts.size(), TheModule); MDValueList.AssignValue(V, NextValueNo++); break; @@ -803,7 +803,7 @@ bool BitcodeReader::ParseMetadata() { 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) { @@ -825,7 +825,7 @@ bool BitcodeReader::ParseMetadata() { String.resize(MDStringLength); for (unsigned i = 0; i != MDStringLength; ++i) String[i] = Record[i]; - Value *V = MDString::get(Context, + Value *V = MDString::get(Context, StringRef(String.data(), String.size())); MDValueList.AssignValue(V, NextValueNo++); break; @@ -833,16 +833,16 @@ bool BitcodeReader::ParseMetadata() { case bitc::METADATA_KIND: { unsigned RecordLength = Record.size(); if (Record.empty() || RecordLength < 2) - return Error("Invalid METADATA_KIND record"); + return Error("Invalid METADATA_KIND record"); SmallString<8> Name; Name.resize(RecordLength-1); MDKindID Kind = Record[0]; for (unsigned i = 1; i != RecordLength; ++i) - Name[i-1] = Record[i]; + Name[i-1] = Record[i]; Metadata &TheMetadata = Context.getMetadata(); - assert(TheMetadata.MDHandlerNames.find(Name.str()) - == TheMetadata.MDHandlerNames.end() && - "Already registered MDKind!"); + assert(TheMetadata.MDHandlerNames.find(Name.str()) + == TheMetadata.MDHandlerNames.end() && + "Already registered MDKind!"); TheMetadata.MDHandlerNames[Name.str()] = Kind; break; } @@ -855,7 +855,7 @@ bool BitcodeReader::ParseMetadata() { 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; @@ -866,7 +866,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); @@ -881,7 +881,7 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { else return Error("Global variable initializer is not a constant!"); } - GlobalInitWorklist.pop_back(); + GlobalInitWorklist.pop_back(); } while (!AliasInitWorklist.empty()) { @@ -894,7 +894,7 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { else return Error("Alias initializer is not a constant!"); } - AliasInitWorklist.pop_back(); + AliasInitWorklist.pop_back(); } return false; } @@ -904,7 +904,7 @@ bool BitcodeReader::ParseConstants() { return Error("Malformed block record"); SmallVector<uint64_t, 64> Record; - + // Read all the records for this value table. const Type *CurTy = Type::getInt32Ty(Context); unsigned NextCstNo = ValueList.size(); @@ -912,7 +912,7 @@ bool BitcodeReader::ParseConstants() { unsigned Code = Stream.ReadCode(); if (Code == bitc::END_BLOCK) break; - + if (Code == bitc::ENTER_SUBBLOCK) { // No known subblocks, always skip them. Stream.ReadSubBlockID(); @@ -920,12 +920,12 @@ 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; @@ -953,13 +953,13 @@ 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(Context, + V = ConstantInt::get(Context, APInt(cast<IntegerType>(CurTy)->getBitWidth(), NumWords, &Words[0])); break; @@ -985,14 +985,14 @@ bool BitcodeReader::ParseConstants() { 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], @@ -1019,7 +1019,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) @@ -1030,10 +1030,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) @@ -1067,7 +1067,7 @@ bool BitcodeReader::ParseConstants() { 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]); @@ -1080,7 +1080,7 @@ 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"); @@ -1107,7 +1107,7 @@ bool BitcodeReader::ParseConstants() { 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); @@ -1132,7 +1132,7 @@ 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::getInt32Ty(Context), + const Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), OpTy->getNumElements()); Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); @@ -1145,7 +1145,7 @@ 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::getInt32Ty(Context), + const Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), RTy->getNumElements()); Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); @@ -1174,7 +1174,7 @@ bool BitcodeReader::ParseConstants() { 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) @@ -1185,17 +1185,17 @@ bool BitcodeReader::ParseConstants() { 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(); @@ -1209,18 +1209,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"); @@ -1231,13 +1231,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; @@ -1271,7 +1271,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. @@ -1313,19 +1313,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. @@ -1388,7 +1388,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; @@ -1406,16 +1406,16 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { isThreadLocal = Record[7]; GlobalVariable *NewGV = - new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, + 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)); @@ -1441,7 +1441,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { 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()) @@ -1455,7 +1455,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) @@ -1470,7 +1470,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. @@ -1490,28 +1490,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' || @@ -1520,17 +1520,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: @@ -1547,7 +1547,7 @@ bool BitcodeReader::ParseBitcode() { break; } } - + return false; } @@ -1555,14 +1555,14 @@ bool BitcodeReader::ParseBitcode() { bool BitcodeReader::ParseMetadataAttachment() { if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) return Error("Malformed block record"); - + Metadata &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"); + return Error("Error at end of PARAMATTR block"); break; } if (Code == bitc::DEFINE_ABBREV) { @@ -1577,12 +1577,12 @@ bool BitcodeReader::ParseMetadataAttachment() { case bitc::METADATA_ATTACHMENT: { unsigned RecordLength = Record.size(); if (Record.empty() || (RecordLength - 1) % 2 == 1) - return Error ("Invalid METADATA_ATTACHMENT reader!"); + return Error ("Invalid METADATA_ATTACHMENT reader!"); Instruction *Inst = InstructionList[Record[0]]; for (unsigned i = 1; i != RecordLength; i = i+2) { - MDKindID Kind = Record[i]; - Value *Node = MDValueList.getValueFwdRef(Record[i+1]); - TheMetadata.setMD(Kind, cast<MDNode>(Node), Inst); + MDKindID Kind = Record[i]; + Value *Node = MDValueList.getValueFwdRef(Record[i+1]); + TheMetadata.setMD(Kind, cast<MDNode>(Node), Inst); } break; } @@ -1595,13 +1595,13 @@ bool BitcodeReader::ParseMetadataAttachment() { 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; @@ -1615,7 +1615,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. @@ -1630,17 +1630,17 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (ParseValueSymbolTable()) return true; break; case bitc::METADATA_ATTACHMENT_ID: - if (ParseMetadataAttachment()) return true; - break; + if (ParseMetadataAttachment()) return true; + break; } continue; } - + if (Code == bitc::DEFINE_ABBREV) { Stream.ReadAbbrevRecord(); continue; } - + // Read a record. Record.clear(); Instruction *I = 0; @@ -1657,7 +1657,7 @@ bool BitcodeReader::ParseFunctionBody(Function *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; @@ -1665,7 +1665,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { getValue(Record, OpNum, LHS->getType(), RHS) || OpNum+1 > Record.size()) return Error("Invalid BINOP record"); - + int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); if (Opc == -1) return Error("Invalid BINOP record"); I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); @@ -1691,7 +1691,7 @@ 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) @@ -1721,7 +1721,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { cast<GetElementPtrInst>(I)->setIsInBounds(true); break; } - + case bitc::FUNC_CODE_INST_EXTRACTVAL: { // EXTRACTVAL: [opty, opval, n x indices] unsigned OpNum = 0; @@ -1743,7 +1743,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { InstructionList.push_back(I); break; } - + case bitc::FUNC_CODE_INST_INSERTVAL: { // INSERTVAL: [opty, opval, opty, opval, n x indices] unsigned OpNum = 0; @@ -1768,7 +1768,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { 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 @@ -1778,12 +1778,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 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] @@ -1798,19 +1798,19 @@ 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::getInt1Ty(Context)) + if (vector_type->getElementType() != Type::getInt1Ty(Context)) return Error("Invalid SELECT condition type"); } else { // expect i1 - if (Cond->getType() != Type::getInt1Ty(Context)) + 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; @@ -1821,12 +1821,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { 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::getInt32Ty(Context), Idx)) return Error("Invalid INSERTELT record"); @@ -1834,7 +1834,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { InstructionList.push_back(I); break; } - + case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] unsigned OpNum = 0; Value *Vec1, *Vec2, *Mask; @@ -1862,7 +1862,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { getValue(Record, OpNum, LHS->getType(), RHS) || OpNum+1 != Record.size()) return Error("Invalid CMP record"); - + if (LHS->getType()->isFPOrFPVector()) I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); else @@ -1882,13 +1882,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { 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(Context); - InstructionList.push_back(I); + InstructionList.push_back(I); break; } @@ -1908,18 +1908,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); + InstructionList.push_back(I); CurBB->getInstList().push_back(I); ValueList.AssignValue(I, NextValueNo++); RV = I; } I = ReturnInst::Create(Context, RV); - InstructionList.push_back(I); + InstructionList.push_back(I); break; } I = ReturnInst::Create(Context, Vs[0]); - InstructionList.push_back(I); + InstructionList.push_back(I); break; } case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] @@ -1931,7 +1931,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (Record.size() == 1) { I = BranchInst::Create(TrueDest); - InstructionList.push_back(I); + InstructionList.push_back(I); } else { BasicBlock *FalseDest = getBasicBlock(Record[1]); @@ -1939,7 +1939,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (FalseDest == 0 || Cond == 0) return Error("Invalid BR record"); I = BranchInst::Create(TrueDest, FalseDest, Cond); - InstructionList.push_back(I); + InstructionList.push_back(I); } break; } @@ -1955,7 +1955,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { 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) { @@ -1967,7 +1967,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"); @@ -1975,12 +1975,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()); @@ -1989,13 +1989,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"); @@ -2008,7 +2008,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Ops.push_back(Op); } } - + I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops.begin(), Ops.end()); InstructionList.push_back(I); @@ -2030,11 +2030,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { 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]); @@ -2044,7 +2044,7 @@ 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"); @@ -2085,7 +2085,7 @@ 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; @@ -2094,11 +2094,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { 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; @@ -2108,11 +2108,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Val, *Ptr; if (getValueTypePair(Record, OpNum, NextValueNo, Val) || - getValue(Record, OpNum, + 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; @@ -2121,21 +2121,21 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // 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) { @@ -2145,7 +2145,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()) @@ -2158,7 +2158,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Args.push_back(Op); } } - + I = CallInst::Create(Callee, Args.begin(), Args.end()); InstructionList.push_back(I); cast<CallInst>(I)->setCallingConv( @@ -2188,18 +2188,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::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) { @@ -2213,11 +2213,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; } @@ -2229,16 +2229,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; @@ -2255,7 +2255,7 @@ bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) { } } } - + return false; } @@ -2263,9 +2263,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); @@ -2281,9 +2281,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) { @@ -2332,7 +2332,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; @@ -2343,25 +2343,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/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index 3d89f3d0f00..3511dbc96ca 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -34,19 +34,19 @@ 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, @@ -102,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; @@ -140,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)); @@ -162,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)); @@ -172,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)); @@ -181,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)); @@ -189,18 +189,18 @@ 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: llvm_unreachable("Unknown type!"); case Type::VoidTyID: Code = bitc::TYPE_CODE_VOID; break; @@ -274,7 +274,7 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) { Stream.EmitRecord(Code, TypeVals, AbbrevToUse); TypeVals.clear(); } - + Stream.ExitBlock(); } @@ -337,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()]; @@ -367,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)); @@ -394,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()); @@ -410,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(); } @@ -435,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) { @@ -496,7 +496,7 @@ static void WriteModuleMetadata(const ValueEnumerator &VE, 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); @@ -506,7 +506,7 @@ static void WriteModuleMetadata(const ValueEnumerator &VE, } 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)); @@ -515,12 +515,12 @@ static void WriteModuleMetadata(const ValueEnumerator &VE, 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(); @@ -540,26 +540,26 @@ static void WriteModuleMetadata(const ValueEnumerator &VE, // Write named metadata elements. for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) { - if (NMD->getElement(i)) + if (NMD->getElement(i)) Record.push_back(VE.getValueID(NMD->getElement(i))); - else + 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) { + 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]]] Metadata &TheMetadata = F.getContext().getMetadata(); @@ -570,41 +570,41 @@ static void WriteMetadataAttachment(const Function &F, if (!P) continue; bool RecordedInstruction = false; for (Metadata::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)); - } + 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 (!StartedMetadataBlock) { - Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3); - StartedMetadataBlock = true; + Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3); + StartedMetadataBlock = true; } Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0); Record.clear(); } - if (StartedMetadataBlock) + if (StartedMetadataBlock) Stream.ExitBlock(); } static void WriteModuleMetadataStore(const Module *M, - const ValueEnumerator &VE, - BitstreamWriter &Stream) { - + const ValueEnumerator &VE, + BitstreamWriter &Stream) { + bool StartedMetadataBlock = false; SmallVector<uint64_t, 64> Record; - + // Write metadata kinds // METADATA_KIND - [n x [id, name]] Metadata &TheMetadata = M->getContext().getMetadata(); const StringMap<unsigned> *Kinds = TheMetadata.getHandlerNames(); - for (StringMap<unsigned>::const_iterator - I = Kinds->begin(), E = Kinds->end(); I != E; ++I) { + 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) @@ -617,7 +617,7 @@ static void WriteModuleMetadataStore(const Module *M, Record.clear(); } - if (StartedMetadataBlock) + if (StartedMetadataBlock) Stream.ExitBlock(); } @@ -625,7 +625,7 @@ 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; @@ -659,8 +659,8 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); CString6Abbrev = Stream.EmitAbbrev(Abbv); - } - + } + SmallVector<uint64_t, 64> Record; const ValueEnumerator::ValueList &Vals = VE.getValues(); @@ -675,16 +675,16 @@ 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())); - + // 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()); @@ -711,11 +711,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]; @@ -765,10 +765,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) @@ -863,7 +863,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) { @@ -883,7 +883,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); @@ -981,7 +981,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, Vals.push_back(cast<CmpInst>(I).getPredicate()); break; - case Instruction::Ret: + case Instruction::Ret: { Code = bitc::FUNC_CODE_INST_RET; unsigned NumOperands = I.getNumOperands(); @@ -1019,13 +1019,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. @@ -1045,38 +1045,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; @@ -1092,16 +1092,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(); @@ -1118,7 +1118,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(); } @@ -1133,27 +1133,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; @@ -1168,12 +1168,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(); @@ -1182,27 +1182,27 @@ 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(); @@ -1211,7 +1211,7 @@ static void WriteFunction(const Function &F, ValueEnumerator &VE, if (I->getType() != Type::getVoidTy(F.getContext())) ++InstID; } - + // Emit names for all the instructions etc. WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream); @@ -1225,9 +1225,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)); @@ -1236,14 +1236,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) { @@ -1251,12 +1251,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(); } @@ -1266,18 +1266,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) llvm_unreachable("Unexpected abbrev ordering!"); } - + { // 7-bit fixed width VST_ENTRY strings. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY)); @@ -1308,9 +1308,9 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv) != VST_BBENTRY_6_ABBREV) llvm_unreachable("Unexpected abbrev ordering!"); } - - - + + + { // SETTYPE abbrev for CONSTANTS_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_SETTYPE)); @@ -1320,7 +1320,7 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv) != CONSTANTS_SETTYPE_ABBREV) llvm_unreachable("Unexpected abbrev ordering!"); } - + { // INTEGER abbrev for CONSTANTS_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_INTEGER)); @@ -1329,7 +1329,7 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv) != CONSTANTS_INTEGER_ABBREV) llvm_unreachable("Unexpected abbrev ordering!"); } - + { // CE_CAST abbrev for CONSTANTS_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CE_CAST)); @@ -1349,9 +1349,9 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv) != CONSTANTS_NULL_Abbrev) 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)); @@ -1394,7 +1394,7 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv) != FUNCTION_INST_CAST_ABBREV) llvm_unreachable("Unexpected abbrev ordering!"); } - + { // INST_RET abbrev for FUNCTION_BLOCK. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET)); @@ -1417,7 +1417,7 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { Abbv) != FUNCTION_INST_UNREACHABLE_ABBREV) llvm_unreachable("Unexpected abbrev ordering!"); } - + Stream.ExitBlock(); } @@ -1425,26 +1425,26 @@ 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); @@ -1462,13 +1462,13 @@ static void WriteModule(const Module *M, BitstreamWriter &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(); } @@ -1476,7 +1476,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. @@ -1493,7 +1493,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. @@ -1502,7 +1502,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' && @@ -1512,10 +1512,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); @@ -1528,7 +1528,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); @@ -1542,18 +1542,18 @@ static void EmitDarwinBCTrailer(BitstreamWriter &Stream, unsigned BufferSize) { 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(); } @@ -1565,7 +1565,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/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp index f4682a2f637..97219afa46e 100644 --- a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp +++ b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp @@ -57,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) @@ -71,25 +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()); - Metadata &TheMetadata = F->getContext().getMetadata(); + Metadata &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()); @@ -98,23 +98,23 @@ ValueEnumerator::ValueEnumerator(const Module *M) { else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) EnumerateAttributes(II->getAttributes()); - // Enumerate metadata attached with this instruction. - const Metadata::MDMapTy *MDs = TheMetadata.getMDs(I); - if (MDs) - for (Metadata::MDMapTy::const_iterator MI = MDs->begin(), - ME = MDs->end(); MI != ME; ++MI) - if (MDNode *MDN = dyn_cast_or_null<MDNode>(MI->second)) - EnumerateMetadata(MDN); + // Enumerate metadata attached with this instruction. + const Metadata::MDMapTy *MDs = TheMetadata.getMDs(I); + if (MDs) + for (Metadata::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. @@ -129,7 +129,7 @@ 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++; @@ -141,12 +141,12 @@ unsigned ValueEnumerator::getValueID(const Value *V) const { 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 { @@ -156,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; @@ -167,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; @@ -185,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); } @@ -193,7 +193,7 @@ 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()); } @@ -254,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. @@ -266,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 @@ -274,7 +274,7 @@ 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)); @@ -291,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) @@ -347,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)) @@ -367,16 +367,16 @@ 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) { @@ -392,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(); } - |
