#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
-#include "llvm/ParamAttrsList.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;
void BitcodeReader::FreeState() {
Buffer = 0;
std::vector<PATypeHolder>().swap(TypeList);
ValueList.clear();
- std::vector<const ParamAttrsList*>().swap(ParamAttrs);
+
+ 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;
+ // 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, 1),
- Op(UndefValue::get(Type::Int32Ty), this) {
+ : 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[i+1] != ParamAttr::None)
Attrs.push_back(ParamAttrsWithIndex::get(Record[i], Record[i+1]));
}
- ParamAttrs.push_back(Attrs.empty() ? NULL : ParamAttrsList::get(Attrs));
+
+ ParamAttrs.push_back(PAListPtr::get(Attrs.begin(), Attrs.end()));
Attrs.clear();
break;
}
if (Record.empty())
return Error("Invalid FLOAT record");
if (CurTy == Type::FloatTy)
- V = ConstantFP::get(CurTy, APFloat(APInt(32, (uint32_t)Record[0])));
+ V = ConstantFP::get(APFloat(APInt(32, (uint32_t)Record[0])));
else if (CurTy == Type::DoubleTy)
- V = ConstantFP::get(CurTy, APFloat(APInt(64, Record[0])));
+ V = ConstantFP::get(APFloat(APInt(64, Record[0])));
else if (CurTy == Type::X86_FP80Ty)
- V = ConstantFP::get(CurTy, APFloat(APInt(80, 2, &Record[0])));
+ V = ConstantFP::get(APFloat(APInt(80, 2, &Record[0])));
else if (CurTy == Type::FP128Ty)
- V = ConstantFP::get(CurTy, APFloat(APInt(128, 2, &Record[0]), true));
+ V = ConstantFP::get(APFloat(APInt(128, 2, &Record[0]), true));
else if (CurTy == Type::PPC_FP128Ty)
- V = ConstantFP::get(CurTy, APFloat(APInt(128, 2, &Record[0])));
+ V = ConstantFP::get(APFloat(APInt(128, 2, &Record[0])));
else
V = UndefValue::get(CurTy);
break;
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 (!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]));
- const ParamAttrsList *PAL = getParamAttrs(Record[4]);
- Func->setParamAttrs(PAL);
+ Func->setParamAttrs(getParamAttrs(Record[4]));
Func->setAlignment((1 << Record[5]) >> 1);
if (Record[6]) {
// 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_BB_UNWINDDEST: // BB_UNWINDDEST: [bb#]
- if (CurBB->getUnwindDest())
- return Error("Only permit one BB_UNWINDDEST per BB");
- if (Record.size() != 1)
- return Error("Invalid BB_UNWINDDEST record");
-
- CurBB->setUnwindDest(getBasicBlock(Record[0]));
- continue;
-
case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode]
unsigned OpNum = 0;
Value *LHS, *RHS;
GEPIdx.push_back(Op);
}
- I = new GetElementPtrInst(BasePtr, GEPIdx.begin(), GEPIdx.end());
+ I = GetElementPtrInst::Create(BasePtr, GEPIdx.begin(), GEPIdx.end());
break;
}
getValue(Record, OpNum, Type::Int1Ty, Cond))
return Error("Invalid SELECT record");
- I = new SelectInst(Cond, TrueVal, FalseVal);
+ I = SelectInst::Create(Cond, TrueVal, FalseVal);
break;
}
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;
}
OpNum+1 != Record.size())
return Error("Invalid CMP record");
- if (LHS->getType()->isFPOrFPVector())
+ if (LHS->getType()->isFloatingPoint())
I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
- else
+ else if (!isa<VectorType>(LHS->getType()))
I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
+ else if (LHS->getType()->isFPOrFPVector())
+ I = new VFCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
+ else
+ I = new VICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
break;
}
case bitc::FUNC_CODE_INST_GETRESULT: { // GETRESULT: [ty, val, n]
{
unsigned Size = Record.size();
if (Size == 0) {
- I = new ReturnInst();
+ I = ReturnInst::Create();
break;
} else {
unsigned OpNum = 0;
} while(OpNum != Record.size());
// SmallVector Vs has at least one element.
- I = new ReturnInst(&Vs[0], Vs.size());
+ I = ReturnInst::Create(&Vs[0], Vs.size());
break;
}
}
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));
case bitc::FUNC_CODE_INST_INVOKE: {
// INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
if (Record.size() < 4) return Error("Invalid INVOKE record");
- const ParamAttrsList *PAL = getParamAttrs(Record[0]);
+ PAListPtr PAL = getParamAttrs(Record[0]);
unsigned CCInfo = Record[1];
BasicBlock *NormalBB = getBasicBlock(Record[2]);
BasicBlock *UnwindBB = getBasicBlock(Record[3]);
}
}
- I = new InvokeInst(Callee, NormalBB, UnwindBB, Ops.begin(), Ops.end());
+ I = InvokeInst::Create(Callee, NormalBB, UnwindBB,
+ Ops.begin(), Ops.end());
cast<InvokeInst>(I)->setCallingConv(CCInfo);
cast<InvokeInst>(I)->setParamAttrs(PAL);
break;
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);
if (Record.size() < 3)
return Error("Invalid CALL record");
- const ParamAttrsList *PAL = getParamAttrs(Record[0]);
+ PAListPtr PAL = getParamAttrs(Record[0]);
unsigned CCInfo = Record[1];
unsigned OpNum = 2;
}
}
- I = new CallInst(Callee, Args.begin(), Args.end());
+ 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);
projects / oota-llvm.git / blobdiff