diff options
author | Dan Gohman <gohman@apple.com> | 2008-05-31 00:58:22 +0000 |
---|---|---|
committer | Dan Gohman <gohman@apple.com> | 2008-05-31 00:58:22 +0000 |
commit | 81a0c0b44e582baca8b68754a7fcabfc3aef2e7a (patch) | |
tree | 0b0d24cd0d230447b1d8419bb0360c74955fdda1 /lib/VMCore/Constants.cpp | |
parent | 652f7ea955bb433d6b7a4d33685dca9485fd7b8b (diff) | |
download | external_llvm-81a0c0b44e582baca8b68754a7fcabfc3aef2e7a.zip external_llvm-81a0c0b44e582baca8b68754a7fcabfc3aef2e7a.tar.gz external_llvm-81a0c0b44e582baca8b68754a7fcabfc3aef2e7a.tar.bz2 |
IR, bitcode reader, bitcode writer, and asmparser changes to
insertvalue and extractvalue to use constant indices instead of
Value* indices. And begin updating LangRef.html.
There's definately more to come here, but I'm checking this
basic support in now to make it available to people who are
interested.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51806 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib/VMCore/Constants.cpp')
-rw-r--r-- | lib/VMCore/Constants.cpp | 216 |
1 files changed, 97 insertions, 119 deletions
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 5753f1f..e15e68a 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -537,15 +537,23 @@ public: /// Constants.cpp, and is used behind the scenes to implement /// extractvalue constant exprs. class VISIBILITY_HIDDEN ExtractValueConstantExpr : public ConstantExpr { - ExtractValueConstantExpr(Constant *Agg, const std::vector<Constant*> &IdxList, - const Type *DestTy); + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT public: - static ExtractValueConstantExpr *Create(Constant *Agg, - const std::vector<Constant*> &IdxList, - const Type *DestTy) { - return - new(IdxList.size() + 1) ExtractValueConstantExpr(Agg, IdxList, DestTy); + // allocate space for exactly one operand + void *operator new(size_t s) { + return User::operator new(s, 1); } + ExtractValueConstantExpr(Constant *Agg, + const SmallVector<unsigned, 4> &IdxList, + const Type *DestTy) + : ConstantExpr(DestTy, Instruction::ExtractValue, &Op<0>(), 1), + Indices(IdxList) { + Op<0>() = Agg; + } + + /// Indicies - These identify which value to extract. + const SmallVector<unsigned, 4> Indices; + /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); }; @@ -554,17 +562,24 @@ public: /// Constants.cpp, and is used behind the scenes to implement /// insertvalue constant exprs. class VISIBILITY_HIDDEN InsertValueConstantExpr : public ConstantExpr { - InsertValueConstantExpr(Constant *Agg, Constant *Val, - const std::vector<Constant*> &IdxList, - const Type *DestTy); + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT public: - static InsertValueConstantExpr *Create(Constant *Agg, Constant *Val, - const std::vector<Constant*> &IdxList, - const Type *DestTy) { - return - new(IdxList.size() + 2) InsertValueConstantExpr(Agg, Val, - IdxList, DestTy); + // allocate space for exactly one operand + void *operator new(size_t s) { + return User::operator new(s, 2); + } + InsertValueConstantExpr(Constant *Agg, Constant *Val, + const SmallVector<unsigned, 4> &IdxList, + const Type *DestTy) + : ConstantExpr(DestTy, Instruction::InsertValue, &Op<0>(), 2), + Indices(IdxList) { + Op<0>() = Agg; + Op<1>() = Val; } + + /// Indicies - These identify the position for the insertion. + const SmallVector<unsigned, 4> Indices; + /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); }; @@ -639,45 +654,15 @@ struct OperandTraits<ShuffleVectorConstantExpr> : FixedNumOperandTraits<3> { DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorConstantExpr, Value) template <> -struct OperandTraits<ExtractValueConstantExpr> : VariadicOperandTraits<1> { +struct OperandTraits<ExtractValueConstantExpr> : FixedNumOperandTraits<1> { }; - -ExtractValueConstantExpr::ExtractValueConstantExpr - (Constant *Agg, - const std::vector<Constant*> &IdxList, - const Type *DestTy) - : ConstantExpr(DestTy, Instruction::ExtractValue, - OperandTraits<ExtractValueConstantExpr>::op_end(this) - - (IdxList.size()+1), - IdxList.size()+1) { - OperandList[0] = Agg; - for (unsigned i = 0, E = IdxList.size(); i != E; ++i) - OperandList[i+1] = IdxList[i]; -} - DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractValueConstantExpr, Value) template <> -struct OperandTraits<InsertValueConstantExpr> : VariadicOperandTraits<2> { +struct OperandTraits<InsertValueConstantExpr> : FixedNumOperandTraits<2> { }; - -InsertValueConstantExpr::InsertValueConstantExpr - (Constant *Agg, Constant *Val, - const std::vector<Constant*> &IdxList, - const Type *DestTy) - : ConstantExpr(DestTy, Instruction::InsertValue, - OperandTraits<InsertValueConstantExpr>::op_end(this) - - (IdxList.size()+2), - IdxList.size()+2) { - OperandList[0] = Agg; - OperandList[1] = Val; - for (unsigned i = 0, E = IdxList.size(); i != E; ++i) - OperandList[i+2] = IdxList[i]; -} - DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueConstantExpr, Value) - template <> struct OperandTraits<GetElementPtrConstantExpr> : VariadicOperandTraits<1> { }; @@ -718,6 +703,21 @@ bool ConstantExpr::isCompare() const { return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp; } +bool ConstantExpr::hasIndices() const { + return getOpcode() == Instruction::ExtractValue || + getOpcode() == Instruction::InsertValue; +} + +const SmallVector<unsigned, 4> &ConstantExpr::getIndices() const { + if (const ExtractValueConstantExpr *EVCE = + dyn_cast<ExtractValueConstantExpr>(this)) + return EVCE->Indices; + if (const InsertValueConstantExpr *IVCE = + dyn_cast<InsertValueConstantExpr>(this)) + return IVCE->Indices; + assert(0 && "ConstantExpr does not have indices!"); +} + /// ConstantExpr::get* - Return some common constants without having to /// specify the full Instruction::OPCODE identifier. /// @@ -829,29 +829,17 @@ ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const { Op2 = (OpNo == 2) ? Op : getOperand(2); return ConstantExpr::getShuffleVector(Op0, Op1, Op2); case Instruction::InsertValue: { - SmallVector<Constant*, 8> Ops; - Ops.resize(getNumOperands()-2); - for (unsigned i = 2, e = getNumOperands(); i != e; ++i) - Ops[i-2] = getOperand(i); - if (OpNo == 0) - return ConstantExpr::getInsertValue(Op, getOperand(1), - &Ops[0], Ops.size()); - if (OpNo == 1) - return ConstantExpr::getInsertValue(getOperand(0), Op, - &Ops[0], Ops.size()); - Ops[OpNo-2] = Op; - return ConstantExpr::getInsertValue(getOperand(0), getOperand(1), - &Ops[0], Ops.size()); + const SmallVector<unsigned, 4> Indices = getIndices(); + Op0 = (OpNo == 0) ? Op : getOperand(0); + Op1 = (OpNo == 1) ? Op : getOperand(1); + return ConstantExpr::getInsertValue(Op0, Op1, + &Indices[0], Indices.size()); } case Instruction::ExtractValue: { - SmallVector<Constant*, 8> Ops; - Ops.resize(getNumOperands()-1); - for (unsigned i = 1, e = getNumOperands(); i != e; ++i) - Ops[i-1] = getOperand(i); - if (OpNo == 0) - return ConstantExpr::getExtractValue(Op, &Ops[0], Ops.size()); - Ops[OpNo-1] = Op; - return ConstantExpr::getExtractValue(getOperand(0), &Ops[0], Ops.size()); + assert(OpNo == 0 && "ExtractaValue has only one operand!"); + const SmallVector<unsigned, 4> Indices = getIndices(); + return + ConstantExpr::getExtractValue(Op, &Indices[0], Indices.size()); } case Instruction::GetElementPtr: { SmallVector<Constant*, 8> Ops; @@ -908,10 +896,16 @@ getWithOperands(const std::vector<Constant*> &Ops) const { return ConstantExpr::getExtractElement(Ops[0], Ops[1]); case Instruction::ShuffleVector: return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]); - case Instruction::InsertValue: - return ConstantExpr::getInsertValue(Ops[0], Ops[1], &Ops[2], Ops.size()-2); - case Instruction::ExtractValue: - return ConstantExpr::getExtractValue(Ops[0], &Ops[1], Ops.size()-1); + case Instruction::InsertValue: { + const SmallVector<unsigned, 4> Indices = getIndices(); + return ConstantExpr::getInsertValue(Ops[0], Ops[1], + &Indices[0], Indices.size()); + } + case Instruction::ExtractValue: { + const SmallVector<unsigned, 4> Indices = getIndices(); + return ConstantExpr::getExtractValue(Ops[0], + &Indices[0], Indices.size()); + } case Instruction::GetElementPtr: return ConstantExpr::getGetElementPtr(Ops[0], &Ops[1], Ops.size()-1); case Instruction::ICmp: @@ -1624,21 +1618,30 @@ void UndefValue::destroyConstant() { namespace { struct ExprMapKeyType { - explicit ExprMapKeyType(unsigned opc, std::vector<Constant*> ops, - unsigned short pred = 0) : opcode(opc), predicate(pred), operands(ops) { } + typedef SmallVector<unsigned, 4> IndexList; + + ExprMapKeyType(unsigned opc, + const std::vector<Constant*> &ops, + unsigned short pred = 0, + const IndexList &inds = IndexList()) + : opcode(opc), predicate(pred), operands(ops), indices(inds) {} uint16_t opcode; uint16_t predicate; std::vector<Constant*> operands; + IndexList indices; bool operator==(const ExprMapKeyType& that) const { return this->opcode == that.opcode && this->predicate == that.predicate && this->operands == that.operands; + this->indices == that.indices; } bool operator<(const ExprMapKeyType & that) const { return this->opcode < that.opcode || (this->opcode == that.opcode && this->predicate < that.predicate) || (this->opcode == that.opcode && this->predicate == that.predicate && - this->operands < that.operands); + this->operands < that.operands) || + (this->opcode == that.opcode && this->predicate == that.predicate && + this->operands == that.operands && this->indices < that.indices); } bool operator!=(const ExprMapKeyType& that) const { @@ -1669,15 +1672,11 @@ namespace llvm { if (V.opcode == Instruction::ShuffleVector) return new ShuffleVectorConstantExpr(V.operands[0], V.operands[1], V.operands[2]); - if (V.opcode == Instruction::InsertValue) { - std::vector<Constant*> IdxList(V.operands.begin()+2, V.operands.end()); - return InsertValueConstantExpr::Create(V.operands[0], V.operands[1], - IdxList, Ty); - } - if (V.opcode == Instruction::ExtractValue) { - std::vector<Constant*> IdxList(V.operands.begin()+1, V.operands.end()); - return ExtractValueConstantExpr::Create(V.operands[0], IdxList, Ty); - } + if (V.opcode == Instruction::InsertValue) + return new InsertValueConstantExpr(V.operands[0], V.operands[1], + V.indices, Ty); + if (V.opcode == Instruction::ExtractValue) + return new ExtractValueConstantExpr(V.operands[0], V.indices, Ty); if (V.opcode == Instruction::GetElementPtr) { std::vector<Constant*> IdxList(V.operands.begin()+1, V.operands.end()); return GetElementPtrConstantExpr::Create(V.operands[0], IdxList, Ty); @@ -1756,7 +1755,9 @@ static ExprMapKeyType getValType(ConstantExpr *CE) { for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) Operands.push_back(cast<Constant>(CE->getOperand(i))); return ExprMapKeyType(CE->getOpcode(), Operands, - CE->isCompare() ? CE->getPredicate() : 0); + CE->isCompare() ? CE->getPredicate() : 0, + CE->hasIndices() ? + CE->getIndices() : SmallVector<unsigned, 4>()); } static ManagedStatic<ValueMap<ExprMapKeyType, Type, @@ -2298,31 +2299,26 @@ Constant *ConstantExpr::getShuffleVector(Constant *V1, Constant *V2, Constant *ConstantExpr::getInsertValueTy(const Type *ReqTy, Constant *Agg, Constant *Val, - Constant *const *Idxs, unsigned NumIdx) { + const unsigned *Idxs, unsigned NumIdx) { assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs, Idxs+NumIdx) == Val->getType() && "insertvalue indices invalid!"); assert(Agg->getType() == ReqTy && "insertvalue type invalid!"); - if (Constant *FC = ConstantFoldInsertValue(Agg, Val, Idxs, NumIdx)) - return FC; // Fold a few common cases... - assert(Agg->getType()->isFirstClassType() && "Non-first-class type for constant InsertValue expression"); // Look up the constant in the table first to ensure uniqueness std::vector<Constant*> ArgVec; - ArgVec.reserve(NumIdx+2); ArgVec.push_back(Agg); ArgVec.push_back(Val); - for (unsigned i = 0; i != NumIdx; ++i) - ArgVec.push_back(cast<Constant>(Idxs[i])); - const ExprMapKeyType Key(Instruction::InsertValue, ArgVec); + SmallVector<unsigned, 4> Indices(Idxs, Idxs + NumIdx); + const ExprMapKeyType Key(Instruction::InsertValue, ArgVec, 0, Indices); return ExprConstants->getOrCreate(ReqTy, Key); } Constant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val, - Constant* const *IdxList, unsigned NumIdx) { + const unsigned *IdxList, unsigned NumIdx) { assert(Agg->getType()->isFirstClassType() && "Tried to create insertelement operation on non-first-class type!"); @@ -2334,28 +2330,22 @@ Constant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val, } Constant *ConstantExpr::getExtractValueTy(const Type *ReqTy, Constant *Agg, - Constant *const *Idxs, unsigned NumIdx) { + const unsigned *Idxs, unsigned NumIdx) { assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs, Idxs+NumIdx) == ReqTy && "extractvalue indices invalid!"); - - if (Constant *FC = ConstantFoldExtractValue(Agg, Idxs, NumIdx)) - return FC; // Fold a few common cases... - assert(Agg->getType()->isFirstClassType() && "Non-first-class type for constant extractvalue expression"); // Look up the constant in the table first to ensure uniqueness std::vector<Constant*> ArgVec; - ArgVec.reserve(NumIdx+1); ArgVec.push_back(Agg); - for (unsigned i = 0; i != NumIdx; ++i) - ArgVec.push_back(cast<Constant>(Idxs[i])); - const ExprMapKeyType Key(Instruction::ExtractValue, ArgVec); + SmallVector<unsigned, 4> Indices; + const ExprMapKeyType Key(Instruction::ExtractValue, ArgVec, 0, Indices); return ExprConstants->getOrCreate(ReqTy, Key); } Constant *ConstantExpr::getExtractValue(Constant *Agg, - Constant* const *IdxList, unsigned NumIdx) { + const unsigned *IdxList, unsigned NumIdx) { assert(Agg->getType()->isFirstClassType() && "Tried to create extractelement operation on non-first-class type!"); @@ -2591,31 +2581,19 @@ void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV, Replacement = ConstantExpr::getGetElementPtr(Pointer, &Indices[0], Indices.size()); } else if (getOpcode() == Instruction::ExtractValue) { - SmallVector<Constant*, 8> Indices; Constant *Agg = getOperand(0); - Indices.reserve(getNumOperands()-1); if (Agg == From) Agg = To; - for (unsigned i = 1, e = getNumOperands(); i != e; ++i) { - Constant *Val = getOperand(i); - if (Val == From) Val = To; - Indices.push_back(Val); - } + const SmallVector<unsigned, 4> &Indices = getIndices(); Replacement = ConstantExpr::getExtractValue(Agg, &Indices[0], Indices.size()); } else if (getOpcode() == Instruction::InsertValue) { - SmallVector<Constant*, 8> Indices; Constant *Agg = getOperand(0); Constant *Val = getOperand(1); - Indices.reserve(getNumOperands()-2); if (Agg == From) Agg = To; if (Val == From) Val = To; - for (unsigned i = 2, e = getNumOperands(); i != e; ++i) { - Constant *Val = getOperand(i); - if (Val == From) Val = To; - Indices.push_back(Val); - } + const SmallVector<unsigned, 4> &Indices = getIndices(); Replacement = ConstantExpr::getInsertValue(Agg, Val, &Indices[0], Indices.size()); } else if (isCast()) { |