X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FConstants.cpp;h=78d24ef5f50617074fbd564cde7508faac0fa077;hb=051a950000e21935165db56695e35bade668193b;hp=49c27b82ccd665254cda5b85a56c680d21a83883;hpb=b348d18caf834bc26a80e60aa7a2c9b1748734e8;p=oota-llvm.git diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 49c27b82ccd..78d24ef5f50 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -225,7 +225,7 @@ ConstantInt *ConstantInt::get(const Type *Ty, uint64_t V, bool isSigned) { } // Get a ConstantInt from an APInt. Note that the value stored in the DenseMap -// as the key, is a DensMapAPIntKeyInfo::KeyTy which has provided the +// as the key, is a DenseMapAPIntKeyInfo::KeyTy which has provided the // operator== and operator!= to ensure that the DenseMap doesn't attempt to // compare APInt's of different widths, which would violate an APInt class // invariant which generates an assertion. @@ -410,8 +410,13 @@ namespace { /// UnaryConstantExpr - This class is private to Constants.cpp, and is used /// behind the scenes to implement unary constant exprs. class VISIBILITY_HIDDEN UnaryConstantExpr : public ConstantExpr { + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT Use Op; public: + // allocate space for exactly one operand + void *operator new(size_t s) { + return User::operator new(s, 1); + } UnaryConstantExpr(unsigned Opcode, Constant *C, const Type *Ty) : ConstantExpr(Ty, Opcode, &Op, 1), Op(C, this) {} }; @@ -419,8 +424,13 @@ public: /// BinaryConstantExpr - This class is private to Constants.cpp, and is used /// behind the scenes to implement binary constant exprs. class VISIBILITY_HIDDEN BinaryConstantExpr : public ConstantExpr { + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT Use Ops[2]; public: + // allocate space for exactly two operands + void *operator new(size_t s) { + return User::operator new(s, 2); + } BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2) : ConstantExpr(C1->getType(), Opcode, Ops, 2) { Ops[0].init(C1, this); @@ -431,8 +441,13 @@ public: /// SelectConstantExpr - This class is private to Constants.cpp, and is used /// behind the scenes to implement select constant exprs. class VISIBILITY_HIDDEN SelectConstantExpr : public ConstantExpr { + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT Use Ops[3]; public: + // allocate space for exactly three operands + void *operator new(size_t s) { + return User::operator new(s, 3); + } SelectConstantExpr(Constant *C1, Constant *C2, Constant *C3) : ConstantExpr(C2->getType(), Instruction::Select, Ops, 3) { Ops[0].init(C1, this); @@ -445,8 +460,13 @@ public: /// Constants.cpp, and is used behind the scenes to implement /// extractelement constant exprs. class VISIBILITY_HIDDEN ExtractElementConstantExpr : public ConstantExpr { + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT Use Ops[2]; public: + // allocate space for exactly two operands + void *operator new(size_t s) { + return User::operator new(s, 2); + } ExtractElementConstantExpr(Constant *C1, Constant *C2) : ConstantExpr(cast(C1->getType())->getElementType(), Instruction::ExtractElement, Ops, 2) { @@ -459,8 +479,13 @@ public: /// Constants.cpp, and is used behind the scenes to implement /// insertelement constant exprs. class VISIBILITY_HIDDEN InsertElementConstantExpr : public ConstantExpr { + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT Use Ops[3]; public: + // allocate space for exactly three operands + void *operator new(size_t s) { + return User::operator new(s, 3); + } InsertElementConstantExpr(Constant *C1, Constant *C2, Constant *C3) : ConstantExpr(C1->getType(), Instruction::InsertElement, Ops, 3) { @@ -474,8 +499,13 @@ public: /// Constants.cpp, and is used behind the scenes to implement /// shufflevector constant exprs. class VISIBILITY_HIDDEN ShuffleVectorConstantExpr : public ConstantExpr { + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT Use Ops[3]; public: + // allocate space for exactly three operands + void *operator new(size_t s) { + return User::operator new(s, 3); + } ShuffleVectorConstantExpr(Constant *C1, Constant *C2, Constant *C3) : ConstantExpr(C1->getType(), Instruction::ShuffleVector, Ops, 3) { @@ -487,7 +517,7 @@ public: /// GetElementPtrConstantExpr - This class is private to Constants.cpp, and is /// used behind the scenes to implement getelementpr constant exprs. -struct VISIBILITY_HIDDEN GetElementPtrConstantExpr : public ConstantExpr { +class VISIBILITY_HIDDEN GetElementPtrConstantExpr : public ConstantExpr { GetElementPtrConstantExpr(Constant *C, const std::vector &IdxList, const Type *DestTy) : ConstantExpr(DestTy, Instruction::GetElementPtr, @@ -496,6 +526,11 @@ struct VISIBILITY_HIDDEN GetElementPtrConstantExpr : public ConstantExpr { for (unsigned i = 0, E = IdxList.size(); i != E; ++i) OperandList[i+1].init(IdxList[i], this); } +public: + static GetElementPtrConstantExpr *Create(Constant *C, const std::vector &IdxList, + const Type *DestTy) { + return new(IdxList.size() + 1/*FIXME*/) GetElementPtrConstantExpr(C, IdxList, DestTy); + } ~GetElementPtrConstantExpr() { delete [] OperandList; } @@ -505,6 +540,11 @@ struct VISIBILITY_HIDDEN GetElementPtrConstantExpr : public ConstantExpr { // behind the scenes to implement ICmp and FCmp constant expressions. This is // needed in order to store the predicate value for these instructions. struct VISIBILITY_HIDDEN CompareConstantExpr : public ConstantExpr { + void *operator new(size_t, unsigned); // DO NOT IMPLEMENT + // allocate space for exactly two operands + void *operator new(size_t s) { + return User::operator new(s, 2); + } unsigned short predicate; Use Ops[2]; CompareConstantExpr(Instruction::OtherOps opc, unsigned short pred, @@ -771,7 +811,8 @@ namespace llvm { template struct VISIBILITY_HIDDEN ConstantCreator { static ConstantClass *create(const TypeClass *Ty, const ValType &V) { - return new ConstantClass(Ty, V); + unsigned FIXME; // = traits::uses(V) + return new(FIXME) ConstantClass(Ty, V); } }; @@ -1433,7 +1474,7 @@ namespace llvm { V.operands[2]); if (V.opcode == Instruction::GetElementPtr) { std::vector IdxList(V.operands.begin()+1, V.operands.end()); - return new GetElementPtrConstantExpr(V.operands[0], IdxList, Ty); + return GetElementPtrConstantExpr::Create(V.operands[0], IdxList, Ty); } // The compare instructions are weird. We have to encode the predicate @@ -1510,7 +1551,7 @@ static ManagedStatic > ExprConstants; /// This is a utility function to handle folding of casts and lookup of the -/// cast in the ExprConstants map. It is usedby the various get* methods below. +/// cast in the ExprConstants map. It is used by the various get* methods below. static inline Constant *getFoldedCast( Instruction::CastOps opc, Constant *C, const Type *Ty) { assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!"); @@ -1710,7 +1751,7 @@ Constant *ConstantExpr::getSizeOf(const Type *Ty) { // sizeof is implemented as: (i64) gep (Ty*)null, 1 Constant *GEPIdx = ConstantInt::get(Type::Int32Ty, 1); Constant *GEP = - getGetElementPtr(getNullValue(PointerType::get(Ty)), &GEPIdx, 1); + getGetElementPtr(getNullValue(PointerType::getUnqual(Ty)), &GEPIdx, 1); return getCast(Instruction::PtrToInt, GEP, Type::Int64Ty); } @@ -1860,7 +1901,8 @@ Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs, const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true); assert(Ty && "GEP indices invalid!"); - return getGetElementPtrTy(PointerType::get(Ty), C, Idxs, NumIdx); + unsigned As = cast(C->getType())->getAddressSpace(); + return getGetElementPtrTy(PointerType::get(Ty, As), C, Idxs, NumIdx); } Constant *ConstantExpr::getGetElementPtr(Constant *C, Constant* const *Idxs,