X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FConstants.cpp;h=530f7ba61aa5a4ac568584c366aa9a6540d75c65;hb=629c1a3f78494d0dd769fe82bd2bd17df0555843;hp=75a2b00fb9aaa43008a5ab7abf2643bcf1fa218d;hpb=041e2eb51721bcfecee5d9c9fc409ff185526e47;p=oota-llvm.git diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 75a2b00fb9a..530f7ba61aa 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -367,7 +367,7 @@ ConstantArray::ConstantArray(const ArrayType *T, (T->isAbstract() && C->getType()->getTypeID() == T->getElementType()->getTypeID())) && "Initializer for array element doesn't match array element type!"); - OL->init(C, this); + *OL = C; } } @@ -389,7 +389,7 @@ ConstantStruct::ConstantStruct(const StructType *T, T->getElementType(I-V.begin())->getTypeID() == C->getType()->getTypeID())) && "Initializer for struct element doesn't match struct element type!"); - OL->init(C, this); + *OL = C; } } @@ -407,7 +407,7 @@ ConstantVector::ConstantVector(const VectorType *T, (T->isAbstract() && C->getType()->getTypeID() == T->getElementType()->getTypeID())) && "Initializer for vector element doesn't match vector element type!"); - OL->init(C, this); + *OL = C; } } @@ -445,8 +445,8 @@ public: } BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2) : ConstantExpr(C1->getType(), Opcode, &Op<0>(), 2) { - Op<0>().init(C1, this); - Op<1>().init(C2, this); + Op<0>() = C1; + Op<1>() = C2; } /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -463,9 +463,9 @@ public: } SelectConstantExpr(Constant *C1, Constant *C2, Constant *C3) : ConstantExpr(C2->getType(), Instruction::Select, &Op<0>(), 3) { - Op<0>().init(C1, this); - Op<1>().init(C2, this); - Op<2>().init(C3, this); + Op<0>() = C1; + Op<1>() = C2; + Op<2>() = C3; } /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -484,8 +484,8 @@ public: ExtractElementConstantExpr(Constant *C1, Constant *C2) : ConstantExpr(cast(C1->getType())->getElementType(), Instruction::ExtractElement, &Op<0>(), 2) { - Op<0>().init(C1, this); - Op<1>().init(C2, this); + Op<0>() = C1; + Op<1>() = C2; } /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -504,9 +504,9 @@ public: InsertElementConstantExpr(Constant *C1, Constant *C2, Constant *C3) : ConstantExpr(C1->getType(), Instruction::InsertElement, &Op<0>(), 3) { - Op<0>().init(C1, this); - Op<1>().init(C2, this); - Op<2>().init(C3, this); + Op<0>() = C1; + Op<1>() = C2; + Op<2>() = C3; } /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -525,9 +525,9 @@ public: ShuffleVectorConstantExpr(Constant *C1, Constant *C2, Constant *C3) : ConstantExpr(C1->getType(), Instruction::ShuffleVector, &Op<0>(), 3) { - Op<0>().init(C1, this); - Op<1>().init(C2, this); - Op<2>().init(C3, this); + Op<0>() = C1; + Op<1>() = C2; + Op<2>() = C3; } /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -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 &IdxList, - const Type *DestTy); + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT public: - static ExtractValueConstantExpr *Create(Constant *Agg, - const std::vector &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 &IdxList, + const Type *DestTy) + : ConstantExpr(DestTy, Instruction::ExtractValue, &Op<0>(), 1), + Indices(IdxList) { + Op<0>() = Agg; + } + + /// Indices - These identify which value to extract. + const SmallVector 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 &IdxList, - const Type *DestTy); + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT public: - static InsertValueConstantExpr *Create(Constant *Agg, Constant *Val, - const std::vector &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 &IdxList, + const Type *DestTy) + : ConstantExpr(DestTy, Instruction::InsertValue, &Op<0>(), 2), + Indices(IdxList) { + Op<0>() = Agg; + Op<1>() = Val; } + + /// Indices - These identify the position for the insertion. + const SmallVector Indices; + /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); }; @@ -599,8 +614,8 @@ struct VISIBILITY_HIDDEN CompareConstantExpr : public ConstantExpr { CompareConstantExpr(const Type *ty, Instruction::OtherOps opc, unsigned short pred, Constant* LHS, Constant* RHS) : ConstantExpr(ty, opc, &Op<0>(), 2), predicate(pred) { - Op<0>().init(LHS, this); - Op<1>().init(RHS, this); + Op<0>() = LHS; + Op<1>() = RHS; } /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -639,45 +654,15 @@ struct OperandTraits : FixedNumOperandTraits<3> { DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorConstantExpr, Value) template <> -struct OperandTraits : VariadicOperandTraits<1> { +struct OperandTraits : FixedNumOperandTraits<1> { }; - -ExtractValueConstantExpr::ExtractValueConstantExpr - (Constant *Agg, - const std::vector &IdxList, - const Type *DestTy) - : ConstantExpr(DestTy, Instruction::ExtractValue, - OperandTraits::op_end(this) - - (IdxList.size()+1), - IdxList.size()+1) { - OperandList[0].init(Agg, this); - for (unsigned i = 0, E = IdxList.size(); i != E; ++i) - OperandList[i+1].init(IdxList[i], this); -} - DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractValueConstantExpr, Value) template <> -struct OperandTraits : VariadicOperandTraits<2> { +struct OperandTraits : FixedNumOperandTraits<2> { }; - -InsertValueConstantExpr::InsertValueConstantExpr - (Constant *Agg, Constant *Val, - const std::vector &IdxList, - const Type *DestTy) - : ConstantExpr(DestTy, Instruction::InsertValue, - OperandTraits::op_end(this) - - (IdxList.size()+2), - IdxList.size()+2) { - OperandList[0].init(Agg, this); - OperandList[1].init(Val, this); - for (unsigned i = 0, E = IdxList.size(); i != E; ++i) - OperandList[i+2].init(IdxList[i], this); -} - DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueConstantExpr, Value) - template <> struct OperandTraits : VariadicOperandTraits<1> { }; @@ -690,9 +675,9 @@ GetElementPtrConstantExpr::GetElementPtrConstantExpr OperandTraits::op_end(this) - (IdxList.size()+1), IdxList.size()+1) { - OperandList[0].init(C, this); + OperandList[0] = C; for (unsigned i = 0, E = IdxList.size(); i != E; ++i) - OperandList[i+1].init(IdxList[i], this); + OperandList[i+1] = IdxList[i]; } DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrConstantExpr, Value) @@ -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 &ConstantExpr::getIndices() const { + if (const ExtractValueConstantExpr *EVCE = + dyn_cast(this)) + return EVCE->Indices; + if (const InsertValueConstantExpr *IVCE = + dyn_cast(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 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 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 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 Indices = getIndices(); + return + ConstantExpr::getExtractValue(Op, &Indices[0], Indices.size()); } case Instruction::GetElementPtr: { SmallVector Ops; @@ -908,10 +896,16 @@ getWithOperands(const std::vector &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 Indices = getIndices(); + return ConstantExpr::getInsertValue(Ops[0], Ops[1], + &Indices[0], Indices.size()); + } + case Instruction::ExtractValue: { + const SmallVector 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 ops, - unsigned short pred = 0) : opcode(opc), predicate(pred), operands(ops) { } + typedef SmallVector IndexList; + + ExprMapKeyType(unsigned opc, + const std::vector &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 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 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 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 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(CE->getOperand(i))); return ExprMapKeyType(CE->getOpcode(), Operands, - CE->isCompare() ? CE->getPredicate() : 0); + CE->isCompare() ? CE->getPredicate() : 0, + CE->hasIndices() ? + CE->getIndices() : SmallVector()); } static ManagedStaticgetType(), Idxs, Idxs+NumIdx) == Val->getType() && "insertvalue indices invalid!"); assert(Agg->getType() == ReqTy && "insertvalue type invalid!"); - - if (Constant *FC = ConstantFoldInsertValue(Agg, Val, Idxs, NumIdx)) + assert(Agg->getType()->isFirstClassType() && + "Non-first-class type for constant InsertValue expression"); + if (Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs, NumIdx)) return FC; // Fold a few common cases... - - assert(isa(Agg->getType()) && - "Non-pointer type for constant InsertValue expression"); // Look up the constant in the table first to ensure uniqueness std::vector ArgVec; - ArgVec.reserve(NumIdx+2); ArgVec.push_back(Agg); ArgVec.push_back(Val); - for (unsigned i = 0; i != NumIdx; ++i) - ArgVec.push_back(cast(Idxs[i])); - const ExprMapKeyType Key(Instruction::InsertValue, ArgVec); + SmallVector 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) { - assert((isa(Agg->getType()) || isa(Agg->getType()) || - isa(Agg->getType())) && - "Tried to create insertelement operation on non-aggregate type!"); + const unsigned *IdxList, unsigned NumIdx) { + assert(Agg->getType()->isFirstClassType() && + "Tried to create insertelement operation on non-first-class type!"); - const Type *ReqTy = + const Type *ReqTy = Agg->getType(); + const Type *ValTy = ExtractValueInst::getIndexedType(Agg->getType(), IdxList, IdxList+NumIdx); - assert(ReqTy && "insertvalue indices invalid!"); + assert(ValTy == Val->getType() && "insertvalue indices invalid!"); return getInsertValueTy(ReqTy, Agg, Val, IdxList, NumIdx); } 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)) + assert(Agg->getType()->isFirstClassType() && + "Non-first-class type for constant extractvalue expression"); + if (Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs, NumIdx)) return FC; // Fold a few common cases... - - assert(isa(Agg->getType()) && - "Non-pointer type for constant ExtractValue expression"); // Look up the constant in the table first to ensure uniqueness std::vector ArgVec; - ArgVec.reserve(NumIdx+1); ArgVec.push_back(Agg); - for (unsigned i = 0; i != NumIdx; ++i) - ArgVec.push_back(cast(Idxs[i])); - const ExprMapKeyType Key(Instruction::ExtractValue, ArgVec); + SmallVector Indices(Idxs, Idxs + NumIdx); + const ExprMapKeyType Key(Instruction::ExtractValue, ArgVec, 0, Indices); return ExprConstants->getOrCreate(ReqTy, Key); } Constant *ConstantExpr::getExtractValue(Constant *Agg, - Constant* const *IdxList, unsigned NumIdx) { - assert((isa(Agg->getType()) || isa(Agg->getType()) || - isa(Agg->getType())) && - "Tried to create extractelement operation on non-aggregate type!"); + const unsigned *IdxList, unsigned NumIdx) { + assert(Agg->getType()->isFirstClassType() && + "Tried to create extractelement operation on non-first-class type!"); const Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), IdxList, IdxList+NumIdx); @@ -2592,31 +2584,19 @@ void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV, Replacement = ConstantExpr::getGetElementPtr(Pointer, &Indices[0], Indices.size()); } else if (getOpcode() == Instruction::ExtractValue) { - SmallVector 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 &Indices = getIndices(); Replacement = ConstantExpr::getExtractValue(Agg, &Indices[0], Indices.size()); } else if (getOpcode() == Instruction::InsertValue) { - SmallVector 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 &Indices = getIndices(); Replacement = ConstantExpr::getInsertValue(Agg, Val, &Indices[0], Indices.size()); } else if (isCast()) {