#include "llvm/DerivedTypes.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
+#include "llvm/ParameterAttributes.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/MemoryBuffer.h"
delete Buffer;
}
+//===----------------------------------------------------------------------===//
+// Helper functions to implement forward reference resolution, etc.
+//===----------------------------------------------------------------------===//
/// ConvertToString - Convert a string from a record into an std::string, return
/// true on failure.
template<typename StrTy>
static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx,
StrTy &Result) {
- if (Record.size() < Idx+1 || Record.size() < Record[Idx]+Idx+1)
+ if (Idx > Record.size())
return true;
- for (unsigned i = 0, e = Record[Idx]; i != e; ++i)
- Result += (char)Record[Idx+i+1];
+ for (unsigned i = Idx, e = Record.size(); i != e; ++i)
+ Result += (char)Record[i];
return false;
}
return TypeList.back().get();
}
+//===----------------------------------------------------------------------===//
+// Functions for parsing blocks from the bitcode file
+//===----------------------------------------------------------------------===//
+
+bool BitcodeReader::ParseParamAttrBlock() {
+ if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
+ return Error("Malformed block record");
+
+ if (!ParamAttrs.empty())
+ return Error("Multiple PARAMATTR blocks found!");
+
+ SmallVector<uint64_t, 64> Record;
+
+ ParamAttrsVector Attrs;
+
+ // Read all the records.
+ while (1) {
+ unsigned Code = Stream.ReadCode();
+ if (Code == bitc::END_BLOCK) {
+ if (Stream.ReadBlockEnd())
+ return Error("Error at end of PARAMATTR block");
+ return false;
+ }
+
+ if (Code == bitc::ENTER_SUBBLOCK) {
+ // No known subblocks, always skip them.
+ Stream.ReadSubBlockID();
+ if (Stream.SkipBlock())
+ return Error("Malformed block record");
+ continue;
+ }
+
+ if (Code == bitc::DEFINE_ABBREV) {
+ Stream.ReadAbbrevRecord();
+ continue;
+ }
+
+ // Read a record.
+ Record.clear();
+ switch (Stream.ReadRecord(Code, Record)) {
+ default: // Default behavior: ignore.
+ break;
+ case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...]
+ 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);
+ }
+ ParamAttrs.push_back(ParamAttrsList::get(Attrs));
+ Attrs.clear();
+ break;
+ }
+ }
+ }
+}
+
+
bool BitcodeReader::ParseTypeTable() {
- if (Stream.EnterSubBlock())
+ if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID))
return Error("Malformed block record");
if (!TypeList.empty())
return Error("Invalid TYPE_CODE_NUMENTRY record");
TypeList.reserve(Record[0]);
continue;
- case bitc::TYPE_CODE_META: // TYPE_CODE_META: [metacode]...
- // No metadata supported yet.
- if (Record.size() < 1)
- return Error("Invalid TYPE_CODE_META record");
- continue;
-
case bitc::TYPE_CODE_VOID: // VOID
ResultTy = Type::VoidTy;
break;
ResultTy = PointerType::get(getTypeByID(Record[0], true));
break;
case bitc::TYPE_CODE_FUNCTION: {
- // FUNCTION: [vararg, retty, #pararms, paramty N]
- if (Record.size() < 3 || Record.size() < Record[2]+3)
+ // FUNCTION: [vararg, attrid, retty, paramty x N]
+ if (Record.size() < 3)
return Error("Invalid FUNCTION type record");
std::vector<const Type*> ArgTys;
- for (unsigned i = 0, e = Record[2]; i != e; ++i)
- ArgTys.push_back(getTypeByID(Record[3+i], true));
+ for (unsigned i = 3, e = Record.size(); i != e; ++i)
+ ArgTys.push_back(getTypeByID(Record[i], true));
- // FIXME: PARAM TYS.
- ResultTy = FunctionType::get(getTypeByID(Record[1], true), ArgTys,
- Record[0]);
+ ResultTy = FunctionType::get(getTypeByID(Record[2], true), ArgTys,
+ Record[0], getParamAttrs(Record[1]));
break;
}
- case bitc::TYPE_CODE_STRUCT: { // STRUCT: [ispacked, #elts, eltty x N]
- if (Record.size() < 2 || Record.size() < Record[1]+2)
+ case bitc::TYPE_CODE_STRUCT: { // STRUCT: [ispacked, eltty x N]
+ if (Record.size() < 2)
return Error("Invalid STRUCT type record");
std::vector<const Type*> EltTys;
- for (unsigned i = 0, e = Record[1]; i != e; ++i)
- EltTys.push_back(getTypeByID(Record[2+i], true));
+ for (unsigned i = 1, e = Record.size(); i != e; ++i)
+ EltTys.push_back(getTypeByID(Record[i], true));
ResultTy = StructType::get(EltTys, Record[0]);
break;
}
bool BitcodeReader::ParseTypeSymbolTable() {
- if (Stream.EnterSubBlock())
+ if (Stream.EnterSubBlock(bitc::TYPE_SYMTAB_BLOCK_ID))
return Error("Malformed block record");
SmallVector<uint64_t, 64> Record;
switch (Stream.ReadRecord(Code, Record)) {
default: // Default behavior: unknown type.
break;
- case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namelen, namechar x N]
+ case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N]
if (ConvertToString(Record, 1, TypeName))
return Error("Invalid TST_ENTRY record");
unsigned TypeID = Record[0];
}
bool BitcodeReader::ParseValueSymbolTable() {
- if (Stream.EnterSubBlock())
+ if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
return Error("Malformed block record");
SmallVector<uint64_t, 64> Record;
switch (Stream.ReadRecord(Code, Record)) {
default: // Default behavior: unknown type.
break;
- case bitc::TST_CODE_ENTRY: // VST_ENTRY: [valueid, namelen, namechar x N]
+ case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
if (ConvertToString(Record, 1, ValueName))
return Error("Invalid TST_ENTRY record");
unsigned ValueID = Record[0];
ValueName.clear();
break;
}
+ case bitc::VST_CODE_BBENTRY: {
+ if (ConvertToString(Record, 1, ValueName))
+ return Error("Invalid VST_BBENTRY record");
+ BasicBlock *BB = getBasicBlock(Record[0]);
+ if (BB == 0)
+ return Error("Invalid BB ID in VST_BBENTRY record");
+
+ BB->setName(&ValueName[0], ValueName.size());
+ ValueName.clear();
+ break;
+ }
+ }
}
}
bool BitcodeReader::ParseConstants() {
- if (Stream.EnterSubBlock())
+ if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
return Error("Malformed block record");
SmallVector<uint64_t, 64> Record;
return Error("Invalid CST_INTEGER record");
V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0]));
break;
- case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n, n x intval]
- if (!isa<IntegerType>(CurTy) || Record.empty() ||
- Record.size() < Record[0]+1)
+ 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[0];
+ unsigned NumWords = Record.size();
SmallVector<uint64_t, 8> Words;
Words.resize(NumWords);
for (unsigned i = 0; i != NumWords; ++i)
- Words[i] = DecodeSignRotatedValue(Record[i+1]);
+ Words[i] = DecodeSignRotatedValue(Record[i]);
V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
NumWords, &Words[0]));
break;
V = UndefValue::get(CurTy);
break;
- case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n, n x value number]
- if (Record.empty() || Record.size() < Record[0]+1)
+ case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
+ if (Record.empty())
return Error("Invalid CST_AGGREGATE record");
- unsigned Size = Record[0];
+ 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+1],
+ Elts.push_back(ValueList.getConstantFwdRef(Record[i],
STy->getElementType(i)));
V = ConstantStruct::get(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+1], EltTy));
+ Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
V = ConstantArray::get(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+1], EltTy));
+ Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
V = ConstantVector::get(Elts);
} else {
V = UndefValue::get(CurTy);
break;
}
case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands]
- if ((Record.size() & 1) == 0) return Error("Invalid CE_GEP record");
+ if (Record.size() & 1) return Error("Invalid CE_GEP record");
SmallVector<Constant*, 16> Elts;
- for (unsigned i = 1, e = Record.size(); i != e; i += 2) {
+ for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
const Type *ElTy = getTypeByID(Record[i]);
if (!ElTy) return Error("Invalid CE_GEP record");
Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
if (TheModule)
return Error("Multiple MODULE_BLOCKs in same stream");
- if (Stream.EnterSubBlock())
+ if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
return Error("Malformed block record");
// Otherwise, create the module.
if (Stream.SkipBlock())
return Error("Malformed block record");
break;
+ case bitc::BLOCKINFO_BLOCK_ID:
+ if (Stream.ReadBlockInfoBlock())
+ return Error("Malformed BlockInfoBlock");
+ break;
+ case bitc::PARAMATTR_BLOCK_ID:
+ if (ParseParamAttrBlock())
+ return true;
+ break;
case bitc::TYPE_BLOCK_ID:
if (ParseTypeTable())
return true;
if (Record[0] != 0)
return Error("Unknown bitstream version!");
break;
- case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strlen, strchr x N]
+ case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
return Error("Invalid MODULE_CODE_TRIPLE record");
TheModule->setTargetTriple(S);
break;
}
- case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strlen, strchr x N]
+ case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
return Error("Invalid MODULE_CODE_DATALAYOUT record");
TheModule->setDataLayout(S);
break;
}
- case bitc::MODULE_CODE_ASM: { // ASM: [strlen, strchr x N]
+ case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
return Error("Invalid MODULE_CODE_ASM record");
TheModule->setModuleInlineAsm(S);
break;
}
- case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strlen, strchr x N]
+ case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
return Error("Invalid MODULE_CODE_DEPLIB record");
TheModule->addLibrary(S);
break;
}
- case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strlen, strchr x N]
+ case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
return Error("Invalid MODULE_CODE_SECTIONNAME record");
unsigned BlockID = Stream.ReadSubBlockID();
// We only know the MODULE subblock ID.
- if (BlockID == bitc::MODULE_BLOCK_ID) {
+ switch (BlockID) {
+ case bitc::BLOCKINFO_BLOCK_ID:
+ if (Stream.ReadBlockInfoBlock())
+ return Error("Malformed BlockInfoBlock");
+ break;
+ case bitc::MODULE_BLOCK_ID:
if (ParseModule(Buffer->getBufferIdentifier()))
return true;
- } else if (Stream.SkipBlock()) {
- return Error("Malformed block record");
+ break;
+ default:
+ if (Stream.SkipBlock())
+ return Error("Malformed block record");
+ break;
}
}
/// ParseFunctionBody - Lazily parse the specified function body block.
bool BitcodeReader::ParseFunctionBody(Function *F) {
- if (Stream.EnterSubBlock())
+ if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
return Error("Malformed block record");
unsigned ModuleValueListSize = ValueList.size();
if (Record.size() < 1 || Record[0] == 0)
return Error("Invalid DECLAREBLOCKS record");
// Create all the basic blocks for the function.
- FunctionBBs.resize(Record.size());
+ FunctionBBs.resize(Record[0]);
for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
FunctionBBs[i] = new BasicBlock("", F);
CurBB = FunctionBBs[0];
I = CastInst::create((Instruction::CastOps)Opc, Op, ResTy);
break;
}
- case bitc::FUNC_CODE_INST_GEP: { // GEP: [n, n x operands]
+ 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]);
if (Record.size() == 2) {
const Type *OpTy = getTypeByID(Record[0]);
Value *Op = getFnValueByID(Record[1], OpTy);
- if (OpTy && Op);
+ if (!OpTy || !Op)
+ return Error("Invalid RET record");
I = new ReturnInst(Op);
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)
+ if (Record.size() != 1 && Record.size() != 3)
return Error("Invalid BR record");
BasicBlock *TrueDest = getBasicBlock(Record[0]);
if (TrueDest == 0)
break;
}
- case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [fnty, op0,op1,op2, ...]
- if (Record.size() < 4)
+ 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[0]));
- Value *Callee = getFnValueByID(Record[1], CalleeTy);
- BasicBlock *NormalBB = getBasicBlock(Record[2]);
- BasicBlock *UnwindBB = getBasicBlock(Record[3]);
+ 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)
return Error("Invalid INVOKE record");
dyn_cast<FunctionType>(CalleeTy->getElementType());
// Check that the right number of fixed parameters are here.
- if (FTy == 0 || Record.size() < 4+FTy->getNumParams())
+ if (FTy == 0 || Record.size() < 5+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[4+i], FTy->getParamType(4+i)));
+ Ops.push_back(getFnValueByID(Record[5+i], FTy->getParamType(i)));
if (Ops.back() == 0)
return Error("Invalid INVOKE record");
}
- unsigned FirstVarargParam = 4+FTy->getNumParams();
+ unsigned FirstVarargParam = 5+FTy->getNumParams();
if (FTy->isVarArg()) {
// Read type/value pairs for varargs params.
if ((Record.size()-FirstVarargParam) & 1)
}
I = new InvokeInst(Callee, NormalBB, UnwindBB, &Ops[0], Ops.size());
+ cast<InvokeInst>(I)->setCallingConv(CCInfo);
break;
}
case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
I = new UnreachableInst();
break;
-#if 0
-
- case bitc::FUNC_CODE_INST_PHI:
- // PHI: [ty, #ops, val0,bb0, ...]
- case bitc::FUNC_CODE_INST_MALLOC:
- // MALLOC: [instty, op, align]
- case bitc::FUNC_CODE_INST_FREE:
- // FREE: [opty, op]
- case bitc::FUNC_CODE_INST_ALLOCA:
- // ALLOCA: [instty, op, align]
- case bitc::FUNC_CODE_INST_LOAD:
- // LOAD: [opty, op, align, vol]
- case bitc::FUNC_CODE_INST_STORE:
- // STORE: [ptrty,val,ptr, align, vol]
- case bitc::FUNC_CODE_INST_CALL:
- // CALL: [fnty, fnid, arg0, arg1...]
- case bitc::FUNC_CODE_INST_VAARG:
- // VAARG: [valistty, valist, instty]
+ case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, #ops, 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);
+
+ 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]);
+ if (!V || !BB) return Error("Invalid PHI record");
+ PN->addIncoming(V, BB);
+ }
+ I = PN;
+ break;
+ }
+
+ case bitc::FUNC_CODE_INST_MALLOC: { // MALLOC: [instty, op, align]
+ if (Record.size() < 3)
+ return Error("Invalid MALLOC record");
+ const PointerType *Ty =
+ dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
+ Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
+ unsigned Align = Record[2];
+ if (!Ty || !Size) return Error("Invalid MALLOC record");
+ 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)
+ return Error("Invalid FREE record");
+ I = new FreeInst(Op);
+ break;
+ }
+ case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, op, align]
+ if (Record.size() < 3)
+ return Error("Invalid ALLOCA record");
+ const PointerType *Ty =
+ dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
+ Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
+ unsigned Align = Record[2];
+ if (!Ty || !Size) return Error("Invalid ALLOCA record");
+ I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1);
+ break;
+ }
+ case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
+ if (Record.size() < 4)
+ 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);
+ 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)
+ return Error("Invalid STORE record");
+ I = new StoreInst(Op, Ptr, Record[4], (1 << Record[3]) >> 1);
+ break;
+ }
+ case bitc::FUNC_CODE_INST_CALL: { // CALL: [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]));
+ 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)
+ 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)));
+ 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())
+ 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");
+ }
+ }
+
+ I = new CallInst(Callee, &Args[0], Args.size());
+ cast<CallInst>(I)->setCallingConv(CCInfo>>1);
+ cast<CallInst>(I)->setTailCall(CCInfo & 1);
break;
-#endif
+ }
+ case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
+ if (Record.size() < 3)
+ return Error("Invalid VAARG record");
+ const Type *OpTy = getTypeByID(Record[0]);
+ Value *Op = getFnValueByID(Record[1], OpTy);
+ const Type *ResTy = getTypeByID(Record[2]);
+ if (!OpTy || !Op || !ResTy)
+ return Error("Invalid VAARG record");
+ I = new VAArgInst(Op, ResTy);
+ break;
+ }
}
// Add instruction to end of current BB. If there is no current BB, reject
delete A;
}
}
+ return Error("Never resolved value found in function!");
}
- return Error("Never resolved value found in function!");
}
// Trim the value list down to the size it was before we parsed this function.