#include "llvm/DerivedTypes.h"
#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
+#include "llvm/LLVMContext.h"
+#include "llvm/MDNode.h"
#include "llvm/Module.h"
#include "llvm/AutoUpgrade.h"
#include "llvm/ADT/SmallString.h"
std::vector<PATypeHolder>().swap(TypeList);
ValueList.clear();
- std::vector<PAListPtr>().swap(ParamAttrs);
+ std::vector<AttrListPtr>().swap(MAttributes);
std::vector<BasicBlock*>().swap(FunctionBBs);
std::vector<Function*>().swap(FunctionsWithBodies);
DeferredFunctionInfo.clear();
switch (Val) {
default: // Map unknown/new linkages to external
case 0: return GlobalValue::ExternalLinkage;
- case 1: return GlobalValue::WeakLinkage;
+ case 1: return GlobalValue::WeakAnyLinkage;
case 2: return GlobalValue::AppendingLinkage;
case 3: return GlobalValue::InternalLinkage;
- case 4: return GlobalValue::LinkOnceLinkage;
+ case 4: return GlobalValue::LinkOnceAnyLinkage;
case 5: return GlobalValue::DLLImportLinkage;
case 6: return GlobalValue::DLLExportLinkage;
case 7: return GlobalValue::ExternalWeakLinkage;
case 8: return GlobalValue::CommonLinkage;
+ case 9: return GlobalValue::PrivateLinkage;
+ case 10: return GlobalValue::WeakODRLinkage;
+ case 11: return GlobalValue::LinkOnceODRLinkage;
+ case 12: return GlobalValue::AvailableExternallyLinkage;
}
}
static int GetDecodedBinaryOpcode(unsigned Val, const Type *Ty) {
switch (Val) {
default: return -1;
- case bitc::BINOP_ADD: return Instruction::Add;
- case bitc::BINOP_SUB: return Instruction::Sub;
- case bitc::BINOP_MUL: return Instruction::Mul;
+ case bitc::BINOP_ADD:
+ return Ty->isFPOrFPVector() ? Instruction::FAdd : Instruction::Add;
+ case bitc::BINOP_SUB:
+ return Ty->isFPOrFPVector() ? Instruction::FSub : Instruction::Sub;
+ case bitc::BINOP_MUL:
+ return Ty->isFPOrFPVector() ? Instruction::FMul : Instruction::Mul;
case bitc::BINOP_UDIV: return Instruction::UDiv;
case bitc::BINOP_SDIV:
return Ty->isFPOrFPVector() ? Instruction::FDiv : Instruction::SDiv;
void *operator new(size_t s) {
return User::operator new(s, 1);
}
- explicit ConstantPlaceHolder(const Type *Ty)
+ explicit ConstantPlaceHolder(const Type *Ty, LLVMContext& Context)
: ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) {
- Op<0>() = UndefValue::get(Type::Int32Ty);
+ Op<0>() = Context.getUndef(Type::Int32Ty);
}
+
+ /// @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) &&
+ cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1;
+ }
+
+
/// Provide fast operand accessors
- DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
+ //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
};
}
-
- // FIXME: can we inherit this from ConstantExpr?
+// 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);
+
+void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) {
+ if (Idx == size()) {
+ 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)) {
+ ResolveConstants.push_back(std::make_pair(PHC, Idx));
+ OldV = V;
+ } else {
+ // If there was a forward reference to this value, replace it.
+ Value *PrevVal = OldV;
+ OldV->replaceAllUsesWith(V);
+ delete PrevVal;
}
}
+
Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
const Type *Ty) {
- if (Idx >= size()) {
- // Insert a bunch of null values.
+ if (Idx >= size())
resize(Idx + 1);
- NumOperands = Idx+1;
- }
- if (Value *V = OperandList[Idx]) {
+ if (Value *V = ValuePtrs[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);
- OperandList[Idx] = C;
+ Constant *C = new ConstantPlaceHolder(Ty, Context);
+ ValuePtrs[Idx] = C;
return C;
}
Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) {
- if (Idx >= size()) {
- // Insert a bunch of null values.
+ if (Idx >= size())
resize(Idx + 1);
- NumOperands = Idx+1;
- }
- if (Value *V = OperandList[Idx]) {
+ if (Value *V = ValuePtrs[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);
- OperandList[Idx] = V;
+ ValuePtrs[Idx] = V;
return V;
}
+/// ResolveConstantForwardRefs - Once all constants are read, this method bulk
+/// resolves any forward references. The idea behind this is that we sometimes
+/// get constants (such as large arrays) which reference *many* forward ref
+/// constants. Replacing each of these causes a lot of thrashing when
+/// building/reuniquing the constant. Instead of doing this, we look at all the
+/// 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
+ // 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);
+ for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end();
+ I != E; ++I) {
+ Value *NewOp;
+ if (!isa<ConstantPlaceHolder>(*I)) {
+ // Not a placeholder reference.
+ NewOp = *I;
+ } else if (*I == Placeholder) {
+ // Common case is that it just references this one placeholder.
+ NewOp = RealVal;
+ } else {
+ // Otherwise, look up the placeholder in ResolveConstants.
+ 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);
+ NewOp = operator[](It->second);
+ }
+
+ NewOps.push_back(cast<Constant>(NewOp));
+ }
+
+ // Make the new constant.
+ Constant *NewC;
+ if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) {
+ NewC = Context.getConstantArray(UserCA->getType(), &NewOps[0],
+ NewOps.size());
+ } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) {
+ NewC = Context.getConstantStruct(&NewOps[0], NewOps.size(),
+ UserCS->getType()->isPacked());
+ } else if (isa<ConstantVector>(UserC)) {
+ NewC = Context.getConstantVector(&NewOps[0], NewOps.size());
+ } else {
+ assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr.");
+ 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;
+ }
+}
+
const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
// If the TypeID is in range, return it.
// The type table allows forward references. Push as many Opaque types as
// needed to get up to ID.
while (TypeList.size() <= ID)
- TypeList.push_back(OpaqueType::get());
+ TypeList.push_back(Context.getOpaqueType());
return TypeList.back().get();
}
// Functions for parsing blocks from the bitcode file
//===----------------------------------------------------------------------===//
-bool BitcodeReader::ParseParamAttrBlock() {
+bool BitcodeReader::ParseAttributeBlock() {
if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
return Error("Malformed block record");
- if (!ParamAttrs.empty())
+ if (!MAttributes.empty())
return Error("Multiple PARAMATTR blocks found!");
SmallVector<uint64_t, 64> Record;
- SmallVector<ParamAttrsWithIndex, 8> Attrs;
+ SmallVector<AttributeWithIndex, 8> Attrs;
// Read all the records.
while (1) {
if (Record.size() & 1)
return Error("Invalid ENTRY record");
+ // FIXME : Remove this autoupgrade code in LLVM 3.0.
+ // If Function attributes are using index 0 then transfer them
+ // to index ~0. Index 0 is used for return value attributes but used to be
+ // used for function attributes.
+ Attributes RetAttribute = Attribute::None;
+ Attributes FnAttribute = Attribute::None;
for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
- if (Record[i+1] != ParamAttr::None)
- Attrs.push_back(ParamAttrsWithIndex::get(Record[i], Record[i+1]));
+ // FIXME: remove in LLVM 3.0
+ // The alignment is stored as a 16-bit raw value from bits 31--16.
+ // We shift the bits above 31 down by 11 bits.
+
+ unsigned Alignment = (Record[i+1] & (0xffffull << 16)) >> 16;
+ if (Alignment && !isPowerOf2_32(Alignment))
+ return Error("Alignment is not a power of two.");
+
+ Attributes ReconstitutedAttr = Record[i+1] & 0xffff;
+ if (Alignment)
+ ReconstitutedAttr |= Attribute::constructAlignmentFromInt(Alignment);
+ ReconstitutedAttr |= (Record[i+1] & (0xffffull << 32)) >> 11;
+ Record[i+1] = ReconstitutedAttr;
+
+ if (Record[i] == 0)
+ RetAttribute = Record[i+1];
+ else if (Record[i] == ~0U)
+ FnAttribute = Record[i+1];
}
- ParamAttrs.push_back(PAListPtr::get(Attrs.begin(), Attrs.end()));
+ 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;
+ }
+
+ for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
+ if (Record[i] == 0) {
+ if (RetAttribute != Attribute::None)
+ Attrs.push_back(AttributeWithIndex::get(0, RetAttribute));
+ } else if (Record[i] == ~0U) {
+ if (FnAttribute != Attribute::None)
+ Attrs.push_back(AttributeWithIndex::get(~0U, FnAttribute));
+ } else if (Record[i+1] != Attribute::None)
+ Attrs.push_back(AttributeWithIndex::get(Record[i], Record[i+1]));
+ }
+
+ MAttributes.push_back(AttrListPtr::get(Attrs.begin(), Attrs.end()));
Attrs.clear();
break;
}
case bitc::TYPE_CODE_OPAQUE: // OPAQUE
ResultTy = 0;
break;
+ case bitc::TYPE_CODE_METADATA: // METADATA
+ ResultTy = Type::MetadataTy;
+ break;
case bitc::TYPE_CODE_INTEGER: // INTEGER: [width]
if (Record.size() < 1)
return Error("Invalid Integer type record");
- ResultTy = IntegerType::get(Record[0]);
+ ResultTy = Context.getIntegerType(Record[0]);
break;
case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
// [pointee type, address space]
unsigned AddressSpace = 0;
if (Record.size() == 2)
AddressSpace = Record[1];
- ResultTy = PointerType::get(getTypeByID(Record[0], true), AddressSpace);
+ ResultTy = Context.getPointerType(getTypeByID(Record[0], true),
+ AddressSpace);
break;
}
case bitc::TYPE_CODE_FUNCTION: {
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,
+ ResultTy = Context.getFunctionType(getTypeByID(Record[2], true), ArgTys,
Record[0]);
break;
}
std::vector<const Type*> EltTys;
for (unsigned i = 1, e = Record.size(); i != e; ++i)
EltTys.push_back(getTypeByID(Record[i], true));
- ResultTy = StructType::get(EltTys, Record[0]);
+ ResultTy = Context.getStructType(EltTys, Record[0]);
break;
}
case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty]
if (Record.size() < 2)
return Error("Invalid ARRAY type record");
- ResultTy = ArrayType::get(getTypeByID(Record[1], true), Record[0]);
+ ResultTy = Context.getArrayType(getTypeByID(Record[1], true), Record[0]);
break;
case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty]
if (Record.size() < 2)
return Error("Invalid VECTOR type record");
- ResultTy = VectorType::get(getTypeByID(Record[1], true), Record[0]);
+ ResultTy = Context.getVectorType(getTypeByID(Record[1], true), Record[0]);
break;
}
if (NumRecords == TypeList.size()) {
// If this is a new type slot, just append it.
- TypeList.push_back(ResultTy ? ResultTy : OpaqueType::get());
+ TypeList.push_back(ResultTy ? ResultTy : Context.getOpaqueType());
++NumRecords;
} else if (ResultTy == 0) {
// Otherwise, this was forward referenced, so an opaque type was created,
break;
case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
if (ConvertToString(Record, 1, ValueName))
- return Error("Invalid TST_ENTRY record");
+ return Error("Invalid VST_ENTRY record");
unsigned ValueID = Record[0];
if (ValueID >= ValueList.size())
return Error("Invalid Value ID in VST_ENTRY record");
unsigned NextCstNo = ValueList.size();
while (1) {
unsigned Code = Stream.ReadCode();
- if (Code == bitc::END_BLOCK) {
- if (NextCstNo != ValueList.size())
- return Error("Invalid constant reference!");
-
- if (Stream.ReadBlockEnd())
- return Error("Error at end of constants block");
- return false;
- }
+ if (Code == bitc::END_BLOCK)
+ break;
if (Code == bitc::ENTER_SUBBLOCK) {
// No known subblocks, always skip them.
switch (Stream.ReadRecord(Code, Record)) {
default: // Default behavior: unknown constant
case bitc::CST_CODE_UNDEF: // UNDEF
- V = UndefValue::get(CurTy);
+ V = Context.getUndef(CurTy);
break;
case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
if (Record.empty())
CurTy = TypeList[Record[0]];
continue; // Skip the ValueList manipulation.
case bitc::CST_CODE_NULL: // NULL
- V = Constant::getNullValue(CurTy);
+ V = Context.getNullValue(CurTy);
break;
case bitc::CST_CODE_INTEGER: // INTEGER: [intval]
if (!isa<IntegerType>(CurTy) || Record.empty())
return Error("Invalid CST_INTEGER record");
- V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0]));
+ V = Context.getConstantInt(CurTy, DecodeSignRotatedValue(Record[0]));
break;
case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
if (!isa<IntegerType>(CurTy) || Record.empty())
Words.resize(NumWords);
for (unsigned i = 0; i != NumWords; ++i)
Words[i] = DecodeSignRotatedValue(Record[i]);
- V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
+ V = Context.getConstantInt(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
NumWords, &Words[0]));
break;
}
if (Record.empty())
return Error("Invalid FLOAT record");
if (CurTy == Type::FloatTy)
- V = ConstantFP::get(APFloat(APInt(32, (uint32_t)Record[0])));
+ V = Context.getConstantFP(APFloat(APInt(32, (uint32_t)Record[0])));
else if (CurTy == Type::DoubleTy)
- V = ConstantFP::get(APFloat(APInt(64, Record[0])));
- else if (CurTy == Type::X86_FP80Ty)
- V = ConstantFP::get(APFloat(APInt(80, 2, &Record[0])));
- else if (CurTy == Type::FP128Ty)
- V = ConstantFP::get(APFloat(APInt(128, 2, &Record[0]), true));
+ V = Context.getConstantFP(APFloat(APInt(64, Record[0])));
+ else if (CurTy == Type::X86_FP80Ty) {
+ // Bits are not stored the same way as a normal i80 APInt, compensate.
+ uint64_t Rearrange[2];
+ Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
+ Rearrange[1] = Record[0] >> 48;
+ V = Context.getConstantFP(APFloat(APInt(80, 2, Rearrange)));
+ } else if (CurTy == Type::FP128Ty)
+ V = Context.getConstantFP(APFloat(APInt(128, 2, &Record[0]), true));
else if (CurTy == Type::PPC_FP128Ty)
- V = ConstantFP::get(APFloat(APInt(128, 2, &Record[0])));
+ V = Context.getConstantFP(APFloat(APInt(128, 2, &Record[0])));
else
- V = UndefValue::get(CurTy);
+ V = Context.getUndef(CurTy);
break;
}
for (unsigned i = 0; i != Size; ++i)
Elts.push_back(ValueList.getConstantFwdRef(Record[i],
STy->getElementType(i)));
- V = ConstantStruct::get(STy, Elts);
+ V = Context.getConstantStruct(STy, Elts);
} else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
const Type *EltTy = ATy->getElementType();
for (unsigned i = 0; i != Size; ++i)
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
- V = ConstantArray::get(ATy, Elts);
+ V = Context.getConstantArray(ATy, Elts);
} else if (const VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
const Type *EltTy = VTy->getElementType();
for (unsigned i = 0; i != Size; ++i)
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
- V = ConstantVector::get(Elts);
+ V = Context.getConstantVector(Elts);
} else {
- V = UndefValue::get(CurTy);
+ V = Context.getUndef(CurTy);
}
break;
}
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);
+ Elts.push_back(Context.getConstantInt(EltTy, Record[i]));
+ V = Context.getConstantArray(ATy, Elts);
break;
}
case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
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);
+ Elts.push_back(Context.getConstantInt(EltTy, Record[i]));
+ Elts.push_back(Context.getNullValue(EltTy));
+ V = Context.getConstantArray(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);
if (Opc < 0) {
- V = UndefValue::get(CurTy); // Unknown binop.
+ V = Context.getUndef(CurTy); // Unknown binop.
} else {
Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
- V = ConstantExpr::get(Opc, LHS, RHS);
+ V = Context.getConstantExpr(Opc, LHS, RHS);
}
break;
}
if (Record.size() < 3) return Error("Invalid CE_CAST record");
int Opc = GetDecodedCastOpcode(Record[0]);
if (Opc < 0) {
- V = UndefValue::get(CurTy); // Unknown cast.
+ V = Context.getUndef(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);
+ V = Context.getConstantExprCast(Opc, Op, CurTy);
}
break;
}
if (!ElTy) return Error("Invalid CE_GEP record");
Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
}
- V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1);
- break;
- }
- case bitc::CST_CODE_CE_EXTRACTVAL: { // CE_EXTRACTVAL: [n x operands]
- if (Record.size() & 1) return Error("Invalid CE_EXTRACTVAL record");
- SmallVector<Constant*, 16> Elts;
- for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
- const Type *ElTy = getTypeByID(Record[i]);
- if (!ElTy) return Error("Invalid CE_EXTRACTVAL record");
- Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
- }
- V = ConstantExpr::getExtractValue(Elts[0], &Elts[1], Elts.size()-1);
- break;
- }
- case bitc::CST_CODE_CE_INSERTVAL: { // CE_INSERTVAL: [n x operands]
- if (Record.size() & 1) return Error("Invalid CE_INSERTVAL record");
- SmallVector<Constant*, 16> Elts;
- for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
- const Type *ElTy = getTypeByID(Record[i]);
- if (!ElTy) return Error("Invalid CE_INSERTVAL record");
- Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
- }
- V = ConstantExpr::getInsertValue(Elts[0], Elts[1],
- &Elts[2], Elts.size()-1);
+ V = Context.getConstantExprGetElementPtr(Elts[0], &Elts[1],
+ Elts.size()-1);
break;
}
case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#]
if (Record.size() < 3) return Error("Invalid CE_SELECT record");
- V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
+ V = Context.getConstantExprSelect(ValueList.getConstantFwdRef(Record[0],
Type::Int1Ty),
ValueList.getConstantFwdRef(Record[1],CurTy),
ValueList.getConstantFwdRef(Record[2],CurTy));
dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record");
Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
- Constant *Op1 = ValueList.getConstantFwdRef(Record[2],
- OpTy->getElementType());
- V = ConstantExpr::getExtractElement(Op0, Op1);
+ Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty);
+ V = Context.getConstantExprExtractElement(Op0, Op1);
break;
}
case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval]
Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
OpTy->getElementType());
Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty);
- V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
+ V = Context.getConstantExprInsertElement(Op0, Op1, Op2);
break;
}
case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
if (Record.size() < 3 || OpTy == 0)
- return Error("Invalid CE_INSERTELT record");
+ return Error("Invalid CE_SHUFFLEVEC record");
Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
- const Type *ShufTy=VectorType::get(Type::Int32Ty, OpTy->getNumElements());
+ const Type *ShufTy = Context.getVectorType(Type::Int32Ty,
+ OpTy->getNumElements());
Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
- V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
+ V = Context.getConstantExprShuffleVector(Op0, Op1, Op2);
+ break;
+ }
+ case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval]
+ const VectorType *RTy = dyn_cast<VectorType>(CurTy);
+ const VectorType *OpTy = dyn_cast<VectorType>(getTypeByID(Record[0]));
+ if (Record.size() < 4 || RTy == 0 || OpTy == 0)
+ return Error("Invalid CE_SHUFVEC_EX record");
+ Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
+ Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
+ const Type *ShufTy = Context.getVectorType(Type::Int32Ty,
+ RTy->getNumElements());
+ Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy);
+ V = Context.getConstantExprShuffleVector(Op0, Op1, Op2);
break;
}
case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred]
Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
if (OpTy->isFloatingPoint())
- V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
- else if (!isa<VectorType>(OpTy))
- V = ConstantExpr::getICmp(Record[3], Op0, Op1);
- else if (OpTy->isFPOrFPVector())
- V = ConstantExpr::getVFCmp(Record[3], Op0, Op1);
+ V = Context.getConstantExprFCmp(Record[3], Op0, Op1);
else
- V = ConstantExpr::getVICmp(Record[3], Op0, Op1);
+ V = Context.getConstantExprICmp(Record[3], Op0, Op1);
break;
}
case bitc::CST_CODE_INLINEASM: {
AsmStr, ConstrStr, HasSideEffects);
break;
}
+ case bitc::CST_CODE_MDSTRING: {
+ unsigned MDStringLength = Record.size();
+ SmallString<8> String;
+ String.resize(MDStringLength);
+ for (unsigned i = 0; i != MDStringLength; ++i)
+ String[i] = Record[i];
+ V = Context.getMDString(String.c_str(), String.c_str() + MDStringLength);
+ break;
+ }
+ case bitc::CST_CODE_MDNODE: {
+ if (Record.empty() || Record.size() % 2 == 1)
+ return Error("Invalid CST_MDNODE record");
+
+ unsigned Size = Record.size();
+ SmallVector<Value*, 8> Elts;
+ for (unsigned i = 0; i != Size; i += 2) {
+ const Type *Ty = getTypeByID(Record[i], false);
+ if (Ty != Type::VoidTy)
+ Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty));
+ else
+ Elts.push_back(NULL);
+ }
+ V = Context.getMDNode(&Elts[0], Elts.size());
+ 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();
+ return false;
}
/// RememberAndSkipFunctionBody - When we see the block for a function body,
return Error("Malformed block record");
// Otherwise, create the module.
- TheModule = new Module(ModuleID);
+ TheModule = new Module(ModuleID, Context);
SmallVector<uint64_t, 64> Record;
std::vector<std::string> SectionTable;
- std::vector<std::string> CollectorTable;
+ std::vector<std::string> GCTable;
// Read all the records for this module.
while (!Stream.AtEndOfStream()) {
return Error("Malformed BlockInfoBlock");
break;
case bitc::PARAMATTR_BLOCK_ID:
- if (ParseParamAttrBlock())
+ if (ParseAttributeBlock())
return true;
break;
case bitc::TYPE_BLOCK_ID:
SectionTable.push_back(S);
break;
}
- case bitc::MODULE_CODE_COLLECTORNAME: { // SECTIONNAME: [strchr x N]
+ case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
- return Error("Invalid MODULE_CODE_COLLECTORNAME record");
- CollectorTable.push_back(S);
+ return Error("Invalid MODULE_CODE_GCNAME record");
+ GCTable.push_back(S);
break;
}
// GLOBALVAR: [pointer type, isconst, initid,
isThreadLocal = Record[7];
GlobalVariable *NewGV =
- new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule,
+ new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0,
isThreadLocal, AddressSpace);
NewGV->setAlignment(Alignment);
if (!Section.empty())
break;
}
// FUNCTION: [type, callingconv, isproto, linkage, paramattr,
- // alignment, section, visibility, collector]
+ // alignment, section, visibility, gc]
case bitc::MODULE_CODE_FUNCTION: {
if (Record.size() < 8)
return Error("Invalid MODULE_CODE_FUNCTION record");
Func->setCallingConv(Record[1]);
bool isProto = Record[2];
Func->setLinkage(GetDecodedLinkage(Record[3]));
- Func->setParamAttrs(getParamAttrs(Record[4]));
+ Func->setAttributes(getAttributes(Record[4]));
Func->setAlignment((1 << Record[5]) >> 1);
if (Record[6]) {
}
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());
+ if (Record[8]-1 > GCTable.size())
+ return Error("Invalid GC ID");
+ 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
return Error("Premature end of bitstream");
}
-
bool BitcodeReader::ParseBitcode() {
TheModule = 0;
return Error("Bitcode stream should be a multiple of 4 bytes in length");
unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart();
- Stream.init(BufPtr, BufPtr+Buffer->getBufferSize());
+ 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' ||
break;
}
- case bitc::FUNC_CODE_INST_EXTRACTVAL: { // EXTRACTVAL: [n x operands]
+ case bitc::FUNC_CODE_INST_EXTRACTVAL: {
+ // EXTRACTVAL: [opty, opval, n x indices]
unsigned OpNum = 0;
Value *Agg;
if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
return Error("Invalid EXTRACTVAL record");
- SmallVector<Value*, 16> EXTRACTVALIdx;
- while (OpNum != Record.size()) {
- Value *Op;
- if (getValueTypePair(Record, OpNum, NextValueNo, Op))
- return Error("Invalid EXTRACTVAL record");
- EXTRACTVALIdx.push_back(Op);
+ SmallVector<unsigned, 4> EXTRACTVALIdx;
+ for (unsigned RecSize = Record.size();
+ OpNum != RecSize; ++OpNum) {
+ uint64_t Index = Record[OpNum];
+ if ((unsigned)Index != Index)
+ return Error("Invalid EXTRACTVAL index");
+ EXTRACTVALIdx.push_back((unsigned)Index);
}
I = ExtractValueInst::Create(Agg,
break;
}
- case bitc::FUNC_CODE_INST_INSERTVAL: { // INSERTVAL: [n x operands]
+ case bitc::FUNC_CODE_INST_INSERTVAL: {
+ // INSERTVAL: [opty, opval, opty, opval, n x indices]
unsigned OpNum = 0;
Value *Agg;
if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
if (getValueTypePair(Record, OpNum, NextValueNo, Val))
return Error("Invalid INSERTVAL record");
- SmallVector<Value*, 16> INSERTVALIdx;
- while (OpNum != Record.size()) {
- Value *Op;
- if (getValueTypePair(Record, OpNum, NextValueNo, Op))
- return Error("Invalid INSERTVAL record");
- INSERTVALIdx.push_back(Op);
+ SmallVector<unsigned, 4> INSERTVALIdx;
+ for (unsigned RecSize = Record.size();
+ OpNum != RecSize; ++OpNum) {
+ uint64_t Index = Record[OpNum];
+ if ((unsigned)Index != Index)
+ return Error("Invalid INSERTVAL index");
+ INSERTVALIdx.push_back((unsigned)Index);
}
I = InsertValueInst::Create(Agg, Val,
}
case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
+ // obsolete form of select
+ // handles select i1 ... in old bitcode
unsigned OpNum = 0;
Value *TrueVal, *FalseVal, *Cond;
if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
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]
+ unsigned OpNum = 0;
+ Value *TrueVal, *FalseVal, *Cond;
+ if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
+ getValue(Record, OpNum, TrueVal->getType(), FalseVal) ||
+ getValueTypePair(Record, OpNum, NextValueNo, Cond))
+ return Error("Invalid SELECT record");
+
+ // select condition can be either i1 or [N x i1]
+ if (const VectorType* vector_type =
+ dyn_cast<const VectorType>(Cond->getType())) {
+ // expect <n x i1>
+ if (vector_type->getElementType() != Type::Int1Ty)
+ return Error("Invalid SELECT condition type");
+ } else {
+ // expect i1
+ if (Cond->getType() != Type::Int1Ty)
+ return Error("Invalid SELECT condition type");
+ }
+
+ I = SelectInst::Create(Cond, TrueVal, FalseVal);
+ break;
+ }
+
case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
unsigned OpNum = 0;
Value *Vec, *Idx;
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))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
return Error("Invalid SHUFFLEVEC record");
I = new ShuffleVectorInst(Vec1, Vec2, Mask);
break;
}
-
- case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred]
+
+ case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred]
+ // Old form of ICmp/FCmp returning bool
+ // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were
+ // both legal on vectors but had different behaviour.
+ case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred]
+ // FCmp/ICmp returning bool or vector of bool
+
unsigned OpNum = 0;
Value *LHS, *RHS;
if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
OpNum+1 != Record.size())
return Error("Invalid CMP record");
- if (LHS->getType()->isFloatingPoint())
- I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
- else if (!isa<VectorType>(LHS->getType()))
- I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
- else if (LHS->getType()->isFPOrFPVector())
- I = new VFCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
+ if (LHS->getType()->isFPOrFPVector())
+ I = new FCmpInst(Context, (FCmpInst::Predicate)Record[OpNum], LHS, RHS);
else
- I = new VICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
+ I = new ICmpInst(Context, (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");
Value *Op;
getValueTypePair(Record, OpNum, NextValueNo, Op);
unsigned Index = Record[1];
- I = new GetResultInst(Op, Index);
+ I = ExtractValueInst::Create(Op, Index);
break;
}
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());
+ }
+
+ 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());
+
+ const Type *ReturnType = F->getReturnType();
+ if (Vs.size() > 1 ||
+ (isa<StructType>(ReturnType) &&
+ (Vs.empty() || Vs[0]->getType() != ReturnType))) {
+ Value *RV = Context.getUndef(ReturnType);
+ for (unsigned i = 0, e = Vs.size(); i != e; ++i) {
+ I = InsertValueInst::Create(RV, Vs[i], i, "mrv");
+ CurBB->getInstList().push_back(I);
+ ValueList.AssignValue(I, NextValueNo++);
+ RV = I;
+ }
+ I = ReturnInst::Create(RV);
break;
}
+
+ I = ReturnInst::Create(Vs[0]);
+ break;
}
case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
if (Record.size() != 1 && Record.size() != 3)
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]);
+ AttrListPtr PAL = getAttributes(Record[0]);
unsigned CCInfo = Record[1];
BasicBlock *NormalBB = getBasicBlock(Record[2]);
BasicBlock *UnwindBB = getBasicBlock(Record[3]);
I = InvokeInst::Create(Callee, NormalBB, UnwindBB,
Ops.begin(), Ops.end());
cast<InvokeInst>(I)->setCallingConv(CCInfo);
- cast<InvokeInst>(I)->setParamAttrs(PAL);
+ cast<InvokeInst>(I)->setAttributes(PAL);
break;
}
case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
unsigned OpNum = 0;
Value *Val, *Ptr;
if (getValueTypePair(Record, OpNum, NextValueNo, Val) ||
- getValue(Record, OpNum, PointerType::getUnqual(Val->getType()), Ptr)||
+ getValue(Record, OpNum,
+ Context.getPointerTypeUnqual(Val->getType()), Ptr)||
OpNum+2 != Record.size())
return Error("Invalid STORE record");
if (Record.size() < 3)
return Error("Invalid CALL record");
- PAListPtr PAL = getParamAttrs(Record[0]);
+ AttrListPtr PAL = getAttributes(Record[0]);
unsigned CCInfo = Record[1];
unsigned OpNum = 2;
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);
+ cast<CallInst>(I)->setAttributes(PAL);
break;
}
case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
// We found at least one unresolved value. Nuke them all to avoid leaks.
for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
- A->replaceAllUsesWith(UndefValue::get(A->getType()));
+ A->replaceAllUsesWith(Context.getUndef(A->getType()));
delete A;
}
}
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;
+ // Iterate over the module, deserializing any functions that are still on
+ // disk.
+ for (Module::iterator F = TheModule->begin(), E = TheModule->end();
+ F != E; ++F)
if (F->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
if (CallInst* CI = dyn_cast<CallInst>(*UI++))
UpgradeIntrinsicCall(CI, I->second);
}
- ValueList.replaceUsesOfWith(I->first, I->second);
+ if (!I->first->use_empty())
+ I->first->replaceAllUsesWith(I->second);
I->first->eraseFromParent();
}
}
/// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
///
ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer,
+ LLVMContext& Context,
std::string *ErrMsg) {
- BitcodeReader *R = new BitcodeReader(Buffer);
+ BitcodeReader *R = new BitcodeReader(Buffer, Context);
if (R->ParseBitcode()) {
if (ErrMsg)
*ErrMsg = R->getErrorString();
/// 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, std::string *ErrMsg){
+Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context,
+ std::string *ErrMsg){
BitcodeReader *R;
- R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
+ R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, Context,
+ ErrMsg));
if (!R) return 0;
// Read in the entire module.
// is run.
if (M)
M = R->releaseModule(ErrMsg);
-
+
delete R;
return M;
}
projects / oota-llvm.git / blobdiff