replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Drop the ConstantInt(const Type&, const APInt&) constructor. It is 

redundant and more verbose than the ConstantInt(const APInt&) constructor.

llvm-svn: 34792
This commit is contained in:
Reid Spencer 2007-03-01 19:30:34 +00:00
parent 2f6ad4d3c3
commit d1bbfa5aa6
2 changed files with 13 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
llvm/include/llvm/Constants.h
View File

@ -90,12 +90,11 @@ public:
}
/// Return a ConstantInt with the specified value for the specified type. The
/// value V will be canonicalized to a uint64_t but accessing it with either
/// getSExtValue() or getZExtValue() (ConstantInt) will yield the correct
/// sized/signed value for the type Ty.
/// value V will be canonicalized to a an unsigned APInt. Accessing it with
/// either getSExtValue() or getZExtValue() will yield a correctly sized and
/// signed value for the type Ty.
/// @brief Get a ConstantInt for a specific value.
static ConstantInt *get(const Type *Ty, int64_t V);
static ConstantInt *get(const Type *Ty, const APInt& V);
static ConstantInt *get(const Type *Ty, uint64_t V);
/// Return a ConstantInt with the specified value and an implied Type. The
/// type is the integer type that corresponds to the bit width of the value.

23
llvm/lib/VMCore/Constants.cpp
View File

@ -115,7 +115,7 @@ Constant *Constant::getNullValue(const Type *Ty) {
// Static constructor to create an integral constant with all bits set
ConstantInt *ConstantInt::getAllOnesValue(const Type *Ty) {
if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
return ConstantInt::get(Ty, APInt::getAllOnesValue(ITy->getBitWidth()));
return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()));
return 0;
}
@ -192,22 +192,21 @@ typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt*,
DenseMapAPIntKeyInfo> IntMapTy;
static ManagedStatic<IntMapTy> IntConstants;
ConstantInt *ConstantInt::get(const Type *Ty, int64_t V) {
ConstantInt *ConstantInt::get(const Type *Ty, uint64_t V) {
const IntegerType *ITy = cast<IntegerType>(Ty);
APInt Tmp(ITy->getBitWidth(), V);
return get(Ty, Tmp);
return get(APInt(ITy->getBitWidth(), V));
}
// Get a ConstantInt from a Type and APInt. Note that the value stored in
// the DenseMap as the key is a DensMapAPIntKeyInfo::KeyTy which has provided
// 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
// 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.
ConstantInt *ConstantInt::get(const Type *Ty, const APInt& V) {
const IntegerType *ITy = cast<IntegerType>(Ty);
assert(ITy->getBitWidth() == V.getBitWidth() && "Invalid type for constant");
ConstantInt *ConstantInt::get(const APInt& V) {
// Get the corresponding integer type for the bit width of the value.
const IntegerType *ITy = IntegerType::get(V.getBitWidth());
// get an existing value or the insertion position
DenseMapAPIntKeyInfo::KeyTy Key(V, Ty);
DenseMapAPIntKeyInfo::KeyTy Key(V, ITy);
ConstantInt *&Slot = (*IntConstants)[Key];
// if it exists, return it.
if (Slot)
@ -216,10 +215,6 @@ ConstantInt *ConstantInt::get(const Type *Ty, const APInt& V) {
return Slot = new ConstantInt(ITy, V);
}
ConstantInt *ConstantInt::get(const APInt &V) {
return ConstantInt::get(IntegerType::get(V.getBitWidth()), V);
}
//===----------------------------------------------------------------------===//
// ConstantFP
//===----------------------------------------------------------------------===//