//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include "BitcodeReader.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
-#include "llvm/ParameterAttributes.h"
+#include "llvm/AutoUpgrade.h"
#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/OperandTraits.h"
using namespace llvm;
-BitcodeReader::~BitcodeReader() {
+void BitcodeReader::FreeState() {
delete Buffer;
+ Buffer = 0;
+ std::vector<PATypeHolder>().swap(TypeList);
+ ValueList.clear();
+
+ std::vector<PAListPtr>().swap(ParamAttrs);
+ std::vector<BasicBlock*>().swap(FunctionBBs);
+ std::vector<Function*>().swap(FunctionsWithBodies);
+ DeferredFunctionInfo.clear();
}
//===----------------------------------------------------------------------===//
case 5: return GlobalValue::DLLImportLinkage;
case 6: return GlobalValue::DLLExportLinkage;
case 7: return GlobalValue::ExternalWeakLinkage;
+ case 8: return GlobalValue::CommonLinkage;
}
}
}
}
-
+namespace llvm {
namespace {
/// @brief A class for maintaining the slot number definition
/// as a placeholder for the actual definition for forward constants defs.
ConstantPlaceHolder(); // DO NOT IMPLEMENT
void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT
public:
- Use Op;
- ConstantPlaceHolder(const Type *Ty)
- : ConstantExpr(Ty, Instruction::UserOp1, &Op, 1),
- Op(UndefValue::get(Type::Int32Ty), this) {
+ // allocate space for exactly one operand
+ void *operator new(size_t s) {
+ return User::operator new(s, 1);
}
+ explicit ConstantPlaceHolder(const Type *Ty)
+ : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) {
+ Op<0>() = UndefValue::get(Type::Int32Ty);
+ }
+ /// Provide fast operand accessors
+ DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
};
}
+
+ // FIXME: can we inherit this from ConstantExpr?
+template <>
+struct OperandTraits<ConstantPlaceHolder> : FixedNumOperandTraits<1> {
+};
+
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantPlaceHolder, Value)
+}
+
+void BitcodeReaderValueList::resize(unsigned Desired) {
+ if (Desired > Capacity) {
+ // Since we expect many values to come from the bitcode file we better
+ // allocate the double amount, so that the array size grows exponentially
+ // at each reallocation. Also, add a small amount of 100 extra elements
+ // each time, to reallocate less frequently when the array is still small.
+ //
+ Capacity = Desired * 2 + 100;
+ Use *New = allocHungoffUses(Capacity);
+ Use *Old = OperandList;
+ unsigned Ops = getNumOperands();
+ for (int i(Ops - 1); i >= 0; --i)
+ New[i] = Old[i].get();
+ OperandList = New;
+ if (Old) Use::zap(Old, Old + Ops, true);
+ }
+}
+
Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
const Type *Ty) {
if (Idx >= size()) {
// Insert a bunch of null values.
- Uses.resize(Idx+1);
- OperandList = &Uses[0];
+ resize(Idx + 1);
NumOperands = Idx+1;
}
- if (Value *V = Uses[Idx]) {
+ if (Value *V = OperandList[Idx]) {
assert(Ty == V->getType() && "Type mismatch in constant table!");
return cast<Constant>(V);
}
// Create and return a placeholder, which will later be RAUW'd.
Constant *C = new ConstantPlaceHolder(Ty);
- Uses[Idx].init(C, this);
+ OperandList[Idx].init(C, this);
return C;
}
Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) {
if (Idx >= size()) {
// Insert a bunch of null values.
- Uses.resize(Idx+1);
- OperandList = &Uses[0];
+ resize(Idx + 1);
NumOperands = Idx+1;
}
- if (Value *V = Uses[Idx]) {
+ if (Value *V = OperandList[Idx]) {
assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!");
return V;
}
// Create and return a placeholder, which will later be RAUW'd.
Value *V = new Argument(Ty);
- Uses[Idx].init(V, this);
+ OperandList[Idx].init(V, this);
return V;
}
SmallVector<uint64_t, 64> Record;
- ParamAttrsVector Attrs;
+ SmallVector<ParamAttrsWithIndex, 8> Attrs;
// Read all the records.
while (1) {
if (Record.size() & 1)
return Error("Invalid ENTRY record");
- ParamAttrsWithIndex PAWI;
for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
- PAWI.index = Record[i];
- PAWI.attrs = Record[i+1];
- Attrs.push_back(PAWI);
+ if (Record[i+1] != ParamAttr::None)
+ Attrs.push_back(ParamAttrsWithIndex::get(Record[i], Record[i+1]));
}
- ParamAttrs.push_back(ParamAttrsList::get(Attrs));
+
+ ParamAttrs.push_back(PAListPtr::get(Attrs.begin(), Attrs.end()));
Attrs.clear();
break;
}
- }
+ }
}
}
case bitc::TYPE_CODE_DOUBLE: // DOUBLE
ResultTy = Type::DoubleTy;
break;
+ case bitc::TYPE_CODE_X86_FP80: // X86_FP80
+ ResultTy = Type::X86_FP80Ty;
+ break;
+ case bitc::TYPE_CODE_FP128: // FP128
+ ResultTy = Type::FP128Ty;
+ break;
+ case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
+ ResultTy = Type::PPC_FP128Ty;
+ break;
case bitc::TYPE_CODE_LABEL: // LABEL
ResultTy = Type::LabelTy;
break;
ResultTy = IntegerType::get(Record[0]);
break;
- case bitc::TYPE_CODE_POINTER: // POINTER: [pointee type]
+ case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
+ // [pointee type, address space]
if (Record.size() < 1)
return Error("Invalid POINTER type record");
- ResultTy = PointerType::get(getTypeByID(Record[0], true));
+ unsigned AddressSpace = 0;
+ if (Record.size() == 2)
+ AddressSpace = Record[1];
+ ResultTy = PointerType::get(getTypeByID(Record[0], true), AddressSpace);
break;
+ }
case bitc::TYPE_CODE_FUNCTION: {
+ // FIXME: attrid is dead, remove it in LLVM 3.0
// FUNCTION: [vararg, attrid, retty, paramty x N]
if (Record.size() < 3)
return Error("Invalid FUNCTION type record");
ArgTys.push_back(getTypeByID(Record[i], true));
ResultTy = FunctionType::get(getTypeByID(Record[2], true), ArgTys,
- Record[0], getParamAttrs(Record[1]));
+ Record[0]);
break;
}
case bitc::TYPE_CODE_STRUCT: { // STRUCT: [ispacked, eltty x N]
- if (Record.size() < 2)
+ if (Record.size() < 1)
return Error("Invalid STRUCT type record");
std::vector<const Type*> EltTys;
for (unsigned i = 1, e = Record.size(); i != e; ++i)
NumWords, &Words[0]));
break;
}
- case bitc::CST_CODE_FLOAT: // FLOAT: [fpval]
+ case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
if (Record.empty())
return Error("Invalid FLOAT record");
if (CurTy == Type::FloatTy)
- V = ConstantFP::get(CurTy, BitsToFloat(Record[0]));
+ V = ConstantFP::get(APFloat(APInt(32, (uint32_t)Record[0])));
else if (CurTy == Type::DoubleTy)
- V = ConstantFP::get(CurTy, BitsToDouble(Record[0]));
+ V = ConstantFP::get(APFloat(APInt(64, Record[0])));
+ else if (CurTy == Type::X86_FP80Ty)
+ V = ConstantFP::get(APFloat(APInt(80, 2, &Record[0])));
+ 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])));
else
V = UndefValue::get(CurTy);
break;
+ }
case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
if (Record.empty())
}
break;
}
+ case bitc::CST_CODE_STRING: { // STRING: [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)
+ Elts.push_back(ConstantInt::get(EltTy, Record[i]));
+ V = ConstantArray::get(ATy, Elts);
+ break;
+ }
+ 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)
+ Elts.push_back(ConstantInt::get(EltTy, Record[i]));
+ Elts.push_back(Constant::getNullValue(EltTy));
+ V = ConstantArray::get(ATy, Elts);
+ break;
+ }
case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]
if (Record.size() < 3) return Error("Invalid CE_BINOP record");
int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
V = UndefValue::get(CurTy); // Unknown cast.
} else {
const Type *OpTy = getTypeByID(Record[1]);
+ if (!OpTy) return Error("Invalid CE_CAST record");
Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
V = ConstantExpr::getCast(Opc, Op, CurTy);
}
if (OpTy->isFloatingPoint())
V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
- else
+ 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);
+ break;
+ }
+ case bitc::CST_CODE_INLINEASM: {
+ if (Record.size() < 2) return Error("Invalid INLINEASM record");
+ std::string AsmStr, ConstrStr;
+ bool HasSideEffects = Record[0];
+ 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;
}
}
SmallVector<uint64_t, 64> Record;
std::vector<std::string> SectionTable;
+ std::vector<std::string> CollectorTable;
// Read all the records for this module.
while (!Stream.AtEndOfStream()) {
if (!FunctionsWithBodies.empty())
return Error("Too few function bodies found");
+ // Look for intrinsic functions which need to be upgraded at some point
+ for (Module::iterator FI = TheModule->begin(), FE = TheModule->end();
+ FI != FE; ++FI) {
+ Function* NewFn;
+ if (UpgradeIntrinsicFunction(FI, NewFn))
+ UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn));
+ }
+
// Force deallocation of memory for these vectors to favor the client that
// want lazy deserialization.
std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
SectionTable.push_back(S);
break;
}
- // GLOBALVAR: [type, isconst, initid,
+ case bitc::MODULE_CODE_COLLECTORNAME: { // SECTIONNAME: [strchr x N]
+ std::string S;
+ if (ConvertToString(Record, 0, S))
+ return Error("Invalid MODULE_CODE_COLLECTORNAME record");
+ CollectorTable.push_back(S);
+ break;
+ }
+ // GLOBALVAR: [pointer type, isconst, initid,
// linkage, alignment, section, visibility, threadlocal]
case bitc::MODULE_CODE_GLOBALVAR: {
if (Record.size() < 6)
const Type *Ty = getTypeByID(Record[0]);
if (!isa<PointerType>(Ty))
return Error("Global not a pointer type!");
+ unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
Ty = cast<PointerType>(Ty)->getElementType();
bool isConstant = Record[1];
Section = SectionTable[Record[5]-1];
}
GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
- if (Record.size() >= 6) Visibility = GetDecodedVisibility(Record[6]);
+ if (Record.size() > 6)
+ Visibility = GetDecodedVisibility(Record[6]);
bool isThreadLocal = false;
- if (Record.size() >= 7) isThreadLocal = Record[7];
+ if (Record.size() > 7)
+ isThreadLocal = Record[7];
GlobalVariable *NewGV =
- new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule);
+ new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule,
+ isThreadLocal, AddressSpace);
NewGV->setAlignment(Alignment);
if (!Section.empty())
NewGV->setSection(Section);
GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
break;
}
- // FUNCTION: [type, callingconv, isproto, linkage, alignment, section,
- // visibility]
+ // FUNCTION: [type, callingconv, isproto, linkage, paramattr,
+ // alignment, section, visibility, collector]
case bitc::MODULE_CODE_FUNCTION: {
- if (Record.size() < 7)
+ if (Record.size() < 8)
return Error("Invalid MODULE_CODE_FUNCTION record");
const Type *Ty = getTypeByID(Record[0]);
if (!isa<PointerType>(Ty))
if (!FTy)
return Error("Function not a pointer to function type!");
- Function *Func = new Function(FTy, GlobalValue::ExternalLinkage,
- "", TheModule);
+ Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage,
+ "", TheModule);
Func->setCallingConv(Record[1]);
bool isProto = Record[2];
Func->setLinkage(GetDecodedLinkage(Record[3]));
- Func->setAlignment((1 << Record[4]) >> 1);
- if (Record[5]) {
- if (Record[5]-1 >= SectionTable.size())
+ Func->setParamAttrs(getParamAttrs(Record[4]));
+
+ Func->setAlignment((1 << Record[5]) >> 1);
+ if (Record[6]) {
+ if (Record[6]-1 >= SectionTable.size())
return Error("Invalid section ID");
- Func->setSection(SectionTable[Record[5]-1]);
+ Func->setSection(SectionTable[Record[6]-1]);
+ }
+ Func->setVisibility(GetDecodedVisibility(Record[7]));
+ if (Record.size() > 8 && Record[8]) {
+ if (Record[8]-1 > CollectorTable.size())
+ return Error("Invalid collector ID");
+ Func->setCollector(CollectorTable[Record[8]-1].c_str());
}
- Func->setVisibility(GetDecodedVisibility(Record[6]));
ValueList.push_back(Func);
break;
}
// ALIAS: [alias type, aliasee val#, linkage]
+ // ALIAS: [alias type, aliasee val#, linkage, visibility]
case bitc::MODULE_CODE_ALIAS: {
if (Record.size() < 3)
return Error("Invalid MODULE_ALIAS record");
GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]),
"", 0, TheModule);
+ // Old bitcode files didn't have visibility field.
+ if (Record.size() > 3)
+ NewGA->setVisibility(GetDecodedVisibility(Record[3]));
ValueList.push_back(NewGA);
AliasInits.push_back(std::make_pair(NewGA, Record[1]));
break;
}
-bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
- // If it already is material, ignore the request.
- if (!F->hasNotBeenReadFromBytecode()) return false;
-
- 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);
- DeferredFunctionInfo.erase(DFII);
-
- if (ParseFunctionBody(F)) {
- if (ErrInfo) *ErrInfo = ErrorString;
- return true;
- }
-
- return false;
-}
-
-Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
- DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I =
- DeferredFunctionInfo.begin();
- while (!DeferredFunctionInfo.empty()) {
- Function *F = (*I++).first;
- assert(F->hasNotBeenReadFromBytecode() &&
- "Deserialized function found in map!");
- if (materializeFunction(F, ErrInfo))
- return 0;
- }
- return TheModule;
-}
-
-
/// ParseFunctionBody - Lazily parse the specified function body block.
bool BitcodeReader::ParseFunctionBody(Function *F) {
if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
// Create all the basic blocks for the function.
FunctionBBs.resize(Record[0]);
for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
- FunctionBBs[i] = new BasicBlock("", F);
+ FunctionBBs[i] = BasicBlock::Create("", F);
CurBB = FunctionBBs[0];
continue;
- case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opcode, ty, opval, opval]
- if (Record.size() < 4) return Error("Invalid BINOP record");
- const Type *Ty = getTypeByID(Record[1]);
- int Opc = GetDecodedBinaryOpcode(Record[0], Ty);
- Value *LHS = getFnValueByID(Record[2], Ty);
- Value *RHS = getFnValueByID(Record[3], Ty);
- if (Opc == -1 || Ty == 0 || LHS == 0 || RHS == 0)
- return Error("Invalid BINOP record");
+ 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())
+ 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);
break;
}
- case bitc::FUNC_CODE_INST_CAST: { // CAST: [opcode, ty, opty, opval]
- if (Record.size() < 4) return Error("Invalid CAST record");
- int Opc = GetDecodedCastOpcode(Record[0]);
- const Type *ResTy = getTypeByID(Record[1]);
- const Type *OpTy = getTypeByID(Record[2]);
- Value *Op = getFnValueByID(Record[3], OpTy);
- if (Opc == -1 || ResTy == 0 || OpTy == 0 || Op == 0)
+ case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc]
+ unsigned OpNum = 0;
+ Value *Op;
+ 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);
break;
}
case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands]
- if (Record.size() < 2 || (Record.size() & 1))
- return Error("Invalid GEP record");
- const Type *OpTy = getTypeByID(Record[0]);
- Value *Op = getFnValueByID(Record[1], OpTy);
- if (OpTy == 0 || Op == 0)
+ unsigned OpNum = 0;
+ Value *BasePtr;
+ if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
return Error("Invalid GEP record");
SmallVector<Value*, 16> GEPIdx;
- for (unsigned i = 1, e = Record.size()/2; i != e; ++i) {
- const Type *IdxTy = getTypeByID(Record[i*2]);
- Value *Idx = getFnValueByID(Record[i*2+1], IdxTy);
- if (IdxTy == 0 || Idx == 0)
+ while (OpNum != Record.size()) {
+ Value *Op;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op))
return Error("Invalid GEP record");
- GEPIdx.push_back(Idx);
+ GEPIdx.push_back(Op);
}
- I = new GetElementPtrInst(Op, &GEPIdx[0], GEPIdx.size());
+ I = GetElementPtrInst::Create(BasePtr, GEPIdx.begin(), GEPIdx.end());
break;
}
- case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [ty, opval, opval, opval]
- if (Record.size() < 4) return Error("Invalid SELECT record");
- const Type *Ty = getTypeByID(Record[0]);
- Value *Cond = getFnValueByID(Record[1], Type::Int1Ty);
- Value *LHS = getFnValueByID(Record[2], Ty);
- Value *RHS = getFnValueByID(Record[3], Ty);
- if (Ty == 0 || Cond == 0 || LHS == 0 || RHS == 0)
+ case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
+ unsigned OpNum = 0;
+ Value *TrueVal, *FalseVal, *Cond;
+ if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
+ getValue(Record, OpNum, TrueVal->getType(), FalseVal) ||
+ getValue(Record, OpNum, Type::Int1Ty, Cond))
return Error("Invalid SELECT record");
- I = new SelectInst(Cond, LHS, RHS);
+
+ I = SelectInst::Create(Cond, TrueVal, FalseVal);
break;
}
case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
- if (Record.size() < 3) return Error("Invalid EXTRACTELT record");
- const Type *OpTy = getTypeByID(Record[0]);
- Value *Vec = getFnValueByID(Record[1], OpTy);
- Value *Idx = getFnValueByID(Record[2], Type::Int32Ty);
- if (OpTy == 0 || Vec == 0 || Idx == 0)
+ unsigned OpNum = 0;
+ Value *Vec, *Idx;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
+ getValue(Record, OpNum, Type::Int32Ty, Idx))
return Error("Invalid EXTRACTELT record");
I = new ExtractElementInst(Vec, Idx);
break;
}
case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
- if (Record.size() < 4) return Error("Invalid INSERTELT record");
- const VectorType *OpTy =
- dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
- if (OpTy == 0) return Error("Invalid INSERTELT record");
- Value *Vec = getFnValueByID(Record[1], OpTy);
- Value *Elt = getFnValueByID(Record[2], OpTy->getElementType());
- Value *Idx = getFnValueByID(Record[3], Type::Int32Ty);
- if (Vec == 0 || Elt == 0 || Idx == 0)
+ unsigned OpNum = 0;
+ Value *Vec, *Elt, *Idx;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
+ getValue(Record, OpNum,
+ cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
+ getValue(Record, OpNum, Type::Int32Ty, Idx))
return Error("Invalid INSERTELT record");
- I = new InsertElementInst(Vec, Elt, Idx);
+ I = InsertElementInst::Create(Vec, Elt, Idx);
break;
}
- case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [ty,opval,opval,opval]
- if (Record.size() < 4) return Error("Invalid SHUFFLEVEC record");
- const VectorType *OpTy =
- dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
- if (OpTy == 0) return Error("Invalid SHUFFLEVEC record");
- Value *Vec1 = getFnValueByID(Record[1], OpTy);
- Value *Vec2 = getFnValueByID(Record[2], OpTy);
- Value *Mask = getFnValueByID(Record[3],
- VectorType::get(Type::Int32Ty,
- OpTy->getNumElements()));
- if (Vec1 == 0 || Vec2 == 0 || Mask == 0)
+ case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
+ unsigned OpNum = 0;
+ Value *Vec1, *Vec2, *Mask;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
+ getValue(Record, OpNum, Vec1->getType(), Vec2))
+ return Error("Invalid SHUFFLEVEC record");
+
+ const Type *MaskTy =
+ VectorType::get(Type::Int32Ty,
+ cast<VectorType>(Vec1->getType())->getNumElements());
+
+ if (getValue(Record, OpNum, MaskTy, Mask))
return Error("Invalid SHUFFLEVEC record");
I = new ShuffleVectorInst(Vec1, Vec2, Mask);
break;
}
case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred]
- if (Record.size() < 4) return Error("Invalid CMP record");
- const Type *OpTy = getTypeByID(Record[0]);
- Value *LHS = getFnValueByID(Record[1], OpTy);
- Value *RHS = getFnValueByID(Record[2], OpTy);
- if (OpTy == 0 || LHS == 0 || RHS == 0)
+ 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 (OpTy->isFPOrFPVector())
- I = new FCmpInst((FCmpInst::Predicate)Record[3], LHS, RHS);
+
+ 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 ICmpInst((ICmpInst::Predicate)Record[3], LHS, RHS);
+ I = new VICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
+ break;
+ }
+ case bitc::FUNC_CODE_INST_GETRESULT: { // GETRESULT: [ty, val, n]
+ if (Record.size() != 2)
+ return Error("Invalid GETRESULT record");
+ unsigned OpNum = 0;
+ Value *Op;
+ getValueTypePair(Record, OpNum, NextValueNo, Op);
+ unsigned Index = Record[1];
+ I = new GetResultInst(Op, Index);
break;
}
case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
- if (Record.size() == 0) {
- I = new ReturnInst();
- break;
- }
- if (Record.size() == 2) {
- const Type *OpTy = getTypeByID(Record[0]);
- Value *Op = getFnValueByID(Record[1], OpTy);
- if (!OpTy || !Op)
- return Error("Invalid RET record");
- I = new ReturnInst(Op);
- break;
+ {
+ unsigned Size = Record.size();
+ if (Size == 0) {
+ I = ReturnInst::Create();
+ break;
+ } else {
+ unsigned OpNum = 0;
+ SmallVector<Value *,4> Vs;
+ do {
+ Value *Op = NULL;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op))
+ return Error("Invalid RET record");
+ Vs.push_back(Op);
+ } while(OpNum != Record.size());
+
+ // SmallVector Vs has at least one element.
+ I = ReturnInst::Create(&Vs[0], Vs.size());
+ break;
+ }
}
- return Error("Invalid RET record");
case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
if (Record.size() != 1 && Record.size() != 3)
return Error("Invalid BR record");
return Error("Invalid BR record");
if (Record.size() == 1)
- I = new BranchInst(TrueDest);
+ I = BranchInst::Create(TrueDest);
else {
BasicBlock *FalseDest = getBasicBlock(Record[1]);
Value *Cond = getFnValueByID(Record[2], Type::Int1Ty);
if (FalseDest == 0 || Cond == 0)
return Error("Invalid BR record");
- I = new BranchInst(TrueDest, FalseDest, Cond);
+ I = BranchInst::Create(TrueDest, FalseDest, Cond);
}
break;
}
if (OpTy == 0 || Cond == 0 || Default == 0)
return Error("Invalid SWITCH record");
unsigned NumCases = (Record.size()-3)/2;
- SwitchInst *SI = new SwitchInst(Cond, Default, NumCases);
+ SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
for (unsigned i = 0, e = NumCases; i != e; ++i) {
ConstantInt *CaseVal =
dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
break;
}
- case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [cc,fnty, op0,op1,op2, ...]
- if (Record.size() < 5)
- return Error("Invalid INVOKE record");
- unsigned CCInfo = Record[0];
- const PointerType *CalleeTy =
- dyn_cast_or_null<PointerType>(getTypeByID(Record[1]));
- Value *Callee = getFnValueByID(Record[2], CalleeTy);
- BasicBlock *NormalBB = getBasicBlock(Record[3]);
- BasicBlock *UnwindBB = getBasicBlock(Record[4]);
- if (CalleeTy == 0 || Callee == 0 || NormalBB == 0 || UnwindBB == 0)
+ case bitc::FUNC_CODE_INST_INVOKE: {
+ // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
+ if (Record.size() < 4) return Error("Invalid INVOKE record");
+ PAListPtr PAL = getParamAttrs(Record[0]);
+ 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 FunctionType *FTy =
+ const PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
+ const FunctionType *FTy = !CalleeTy ? 0 :
dyn_cast<FunctionType>(CalleeTy->getElementType());
// Check that the right number of fixed parameters are here.
- if (FTy == 0 || Record.size() < 5+FTy->getNumParams())
+ 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) {
- Ops.push_back(getFnValueByID(Record[5+i], FTy->getParamType(i)));
- if (Ops.back() == 0)
- return Error("Invalid INVOKE record");
+ 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");
}
- unsigned FirstVarargParam = 5+FTy->getNumParams();
- if (FTy->isVarArg()) {
- // Read type/value pairs for varargs params.
- if ((Record.size()-FirstVarargParam) & 1)
+ if (!FTy->isVarArg()) {
+ if (Record.size() != OpNum)
return Error("Invalid INVOKE record");
-
- for (unsigned i = FirstVarargParam, e = Record.size(); i != e; i += 2) {
- const Type *ArgTy = getTypeByID(Record[i]);
- Ops.push_back(getFnValueByID(Record[i+1], ArgTy));
- if (Ops.back() == 0 || ArgTy == 0)
+ } else {
+ // Read type/value pairs for varargs params.
+ while (OpNum != Record.size()) {
+ Value *Op;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op))
return Error("Invalid INVOKE record");
+ Ops.push_back(Op);
}
- } else {
- if (Record.size() != FirstVarargParam)
- return Error("Invalid INVOKE record");
}
- I = new InvokeInst(Callee, NormalBB, UnwindBB, &Ops[0], Ops.size());
+ I = InvokeInst::Create(Callee, NormalBB, UnwindBB,
+ Ops.begin(), Ops.end());
cast<InvokeInst>(I)->setCallingConv(CCInfo);
+ cast<InvokeInst>(I)->setParamAttrs(PAL);
break;
}
case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
I = new UnreachableInst();
break;
- case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, #ops, val0,bb0, ...]
+ 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 = new PHINode(Ty);
- PN->reserveOperandSpace(Record.size()-1);
+ PHINode *PN = PHINode::Create(Ty);
+ 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);
I = new MallocInst(Ty->getElementType(), Size, (1 << Align) >> 1);
break;
}
- case bitc::FUNC_CODE_INST_FREE: { // FREE: [opty, op]
- if (Record.size() < 2)
- return Error("Invalid FREE record");
- const Type *OpTy = getTypeByID(Record[0]);
- Value *Op = getFnValueByID(Record[1], OpTy);
- if (!OpTy || !Op)
+ case bitc::FUNC_CODE_INST_FREE: { // FREE: [op, opty]
+ unsigned OpNum = 0;
+ Value *Op;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
+ OpNum != Record.size())
return Error("Invalid FREE record");
I = new FreeInst(Op);
break;
break;
}
case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
- if (Record.size() < 4)
+ unsigned OpNum = 0;
+ Value *Op;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
+ OpNum+2 != Record.size())
return Error("Invalid LOAD record");
- const Type *OpTy = getTypeByID(Record[0]);
- Value *Op = getFnValueByID(Record[1], OpTy);
- if (!OpTy || !Op)
- return Error("Invalid LOAD record");
- I = new LoadInst(Op, "", Record[3], (1 << Record[2]) >> 1);
+
+ I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1);
break;
}
- case bitc::FUNC_CODE_INST_STORE: { // STORE:[ptrty,val,ptr, align, vol]
- if (Record.size() < 5)
- return Error("Invalid LOAD record");
- const PointerType *OpTy =
- dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
- Value *Op = getFnValueByID(Record[1], OpTy ? OpTy->getElementType() : 0);
- Value *Ptr = getFnValueByID(Record[2], OpTy);
- if (!OpTy || !Op || !Ptr)
+ 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,
+ cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
+ OpNum+2 != Record.size())
return Error("Invalid STORE record");
- I = new StoreInst(Op, Ptr, Record[4], (1 << Record[3]) >> 1);
+
+ I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1);
+ break;
+ }
+ case bitc::FUNC_CODE_INST_STORE: { // STORE:[val, valty, ptr, align, vol]
+ // FIXME: Legacy form of store instruction. Should be removed in LLVM 3.0.
+ unsigned OpNum = 0;
+ Value *Val, *Ptr;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Val) ||
+ 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);
break;
}
- case bitc::FUNC_CODE_INST_CALL: { // CALL: [cc, fnty, fnid, arg0, arg1...]
+ case bitc::FUNC_CODE_INST_CALL: {
+ // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...]
if (Record.size() < 3)
return Error("Invalid CALL record");
- unsigned CCInfo = Record[0];
- const PointerType *OpTy =
- dyn_cast_or_null<PointerType>(getTypeByID(Record[1]));
+
+ PAListPtr PAL = getParamAttrs(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());
- Value *Callee = getFnValueByID(Record[2], OpTy);
- if (!FTy || !Callee || Record.size() < FTy->getNumParams()+3)
+ 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) {
- Args.push_back(getFnValueByID(Record[i+3], FTy->getParamType(i)));
+ for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
+ if (FTy->getParamType(i)->getTypeID()==Type::LabelTyID)
+ Args.push_back(getBasicBlock(Record[OpNum]));
+ else
+ 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.
- unsigned NextArg = FTy->getNumParams()+3;
if (!FTy->isVarArg()) {
- if (NextArg != Record.size())
+ if (OpNum != Record.size())
return Error("Invalid CALL record");
} else {
- if ((Record.size()-NextArg) & 1)
- return Error("Invalid CALL record");
- for (unsigned e = Record.size(); NextArg != e; NextArg += 2) {
- Args.push_back(getFnValueByID(Record[NextArg+1],
- getTypeByID(Record[NextArg])));
- if (Args.back() == 0) return Error("Invalid CALL record");
+ while (OpNum != Record.size()) {
+ Value *Op;
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op))
+ return Error("Invalid CALL record");
+ Args.push_back(Op);
}
}
- I = new CallInst(Callee, &Args[0], Args.size());
+ I = CallInst::Create(Callee, Args.begin(), Args.end());
cast<CallInst>(I)->setCallingConv(CCInfo>>1);
cast<CallInst>(I)->setTailCall(CCInfo & 1);
+ cast<CallInst>(I)->setParamAttrs(PAL);
break;
}
case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
return false;
}
+//===----------------------------------------------------------------------===//
+// ModuleProvider implementation
+//===----------------------------------------------------------------------===//
+
+
+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 =
+ 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;
+ }
+
+ // Upgrade any old intrinsic calls in the function.
+ for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(),
+ E = UpgradedIntrinsics.end(); I != E; ++I) {
+ if (I->first != I->second) {
+ for (Value::use_iterator UI = I->first->use_begin(),
+ UE = I->first->use_end(); UI != UE; ) {
+ if (CallInst* CI = dyn_cast<CallInst>(*UI++))
+ UpgradeIntrinsicCall(CI, I->second);
+ }
+ }
+ }
+
+ return false;
+}
+
+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);
+}
+
+
+Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
+ for (DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I =
+ DeferredFunctionInfo.begin(), E = DeferredFunctionInfo.end(); I != E;
+ ++I) {
+ Function *F = I->first;
+ if (F->hasNotBeenReadFromBitcode() &&
+ 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
+ // with calls to the old function.
+ for (std::vector<std::pair<Function*, Function*> >::iterator I =
+ UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) {
+ if (I->first != I->second) {
+ for (Value::use_iterator UI = I->first->use_begin(),
+ UE = I->first->use_end(); UI != UE; ) {
+ if (CallInst* CI = dyn_cast<CallInst>(*UI++))
+ UpgradeIntrinsicCall(CI, I->second);
+ }
+ ValueList.replaceUsesOfWith(I->first, I->second);
+ I->first->eraseFromParent();
+ }
+ }
+ std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics);
+
+ return TheModule;
+}
+
+
+/// This method is provided by the parent ModuleProvde class and overriden
+/// here. It simply releases the module from its provided and frees up our
+/// state.
+/// @brief Release our hold on the generated module
+Module *BitcodeReader::releaseModule(std::string *ErrInfo) {
+ // Since we're losing control of this Module, we must hand it back complete
+ Module *M = ModuleProvider::releaseModule(ErrInfo);
+ FreeState();
+ return M;
+}
+
//===----------------------------------------------------------------------===//
// External interface
R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
if (!R) return 0;
- // Read the whole module, get a pointer to it, tell ModuleProvider not to
- // delete it when its dtor is run.
- Module *M = R->releaseModule(ErrMsg);
-
- // Don't let the BitcodeReader dtor delete 'Buffer'.
+ // 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;
}
projects / oota-llvm.git / blobdiff