2003-05-13 21:37:02 +00:00
|
|
|
//===-- Constants.cpp - Implement Constant nodes --------------------------===//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2001-12-03 22:26:30 +00:00
|
|
|
// This file implements the Constant* classes...
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2002-04-28 19:55:58 +00:00
|
|
|
#include "llvm/Constants.h"
|
2007-02-27 03:05:06 +00:00
|
|
|
#include "ConstantFold.h"
|
2001-06-06 20:29:01 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2004-07-17 23:48:33 +00:00
|
|
|
#include "llvm/GlobalValue.h"
|
2004-07-29 17:30:56 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2001-10-13 06:57:33 +00:00
|
|
|
#include "llvm/Module.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2006-08-27 12:54:02 +00:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2006-11-17 08:03:48 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2006-09-28 00:35:06 +00:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2006-11-17 08:03:48 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2007-02-20 06:39:57 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2007-02-19 20:01:23 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2001-06-06 20:29:01 +00:00
|
|
|
#include <algorithm>
|
2007-02-05 20:47:22 +00:00
|
|
|
#include <map>
|
2003-11-21 20:23:48 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-12-03 22:26:30 +00:00
|
|
|
// Constant Class
|
2001-06-06 20:29:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2002-08-13 17:50:20 +00:00
|
|
|
void Constant::destroyConstantImpl() {
|
|
|
|
// When a Constant is destroyed, there may be lingering
|
|
|
|
// references to the constant by other constants in the constant pool. These
|
2003-08-21 22:14:26 +00:00
|
|
|
// constants are implicitly dependent on the module that is being deleted,
|
2002-08-13 17:50:20 +00:00
|
|
|
// but they don't know that. Because we only find out when the CPV is
|
|
|
|
// deleted, we must now notify all of our users (that should only be
|
|
|
|
// Constants) that they are, in fact, invalid now and should be deleted.
|
|
|
|
//
|
|
|
|
while (!use_empty()) {
|
|
|
|
Value *V = use_back();
|
|
|
|
#ifndef NDEBUG // Only in -g mode...
|
|
|
|
if (!isa<Constant>(V))
|
2006-11-17 08:03:48 +00:00
|
|
|
DOUT << "While deleting: " << *this
|
|
|
|
<< "\n\nUse still stuck around after Def is destroyed: "
|
|
|
|
<< *V << "\n\n";
|
2002-08-13 17:50:20 +00:00
|
|
|
#endif
|
|
|
|
assert(isa<Constant>(V) && "References remain to Constant being destroyed");
|
2004-07-17 23:48:33 +00:00
|
|
|
Constant *CV = cast<Constant>(V);
|
|
|
|
CV->destroyConstant();
|
2002-08-13 17:50:20 +00:00
|
|
|
|
|
|
|
// The constant should remove itself from our use list...
|
|
|
|
assert((use_empty() || use_back() != V) && "Constant not removed!");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Value has no outstanding references it is safe to delete it now...
|
|
|
|
delete this;
|
|
|
|
}
|
|
|
|
|
2006-10-20 00:27:06 +00:00
|
|
|
/// canTrap - Return true if evaluation of this constant could trap. This is
|
|
|
|
/// true for things like constant expressions that could divide by zero.
|
|
|
|
bool Constant::canTrap() const {
|
|
|
|
assert(getType()->isFirstClassType() && "Cannot evaluate aggregate vals!");
|
|
|
|
// The only thing that could possibly trap are constant exprs.
|
|
|
|
const ConstantExpr *CE = dyn_cast<ConstantExpr>(this);
|
|
|
|
if (!CE) return false;
|
|
|
|
|
|
|
|
// ConstantExpr traps if any operands can trap.
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
|
|
|
|
if (getOperand(i)->canTrap())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Otherwise, only specific operations can trap.
|
|
|
|
switch (CE->getOpcode()) {
|
|
|
|
default:
|
|
|
|
return false;
|
2006-10-26 06:15:43 +00:00
|
|
|
case Instruction::UDiv:
|
|
|
|
case Instruction::SDiv:
|
|
|
|
case Instruction::FDiv:
|
2006-11-02 01:53:59 +00:00
|
|
|
case Instruction::URem:
|
|
|
|
case Instruction::SRem:
|
|
|
|
case Instruction::FRem:
|
2006-10-20 00:27:06 +00:00
|
|
|
// Div and rem can trap if the RHS is not known to be non-zero.
|
|
|
|
if (!isa<ConstantInt>(getOperand(1)) || getOperand(1)->isNullValue())
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-03-08 00:59:12 +00:00
|
|
|
/// ContaintsRelocations - Return true if the constant value contains
|
|
|
|
/// relocations which cannot be resolved at compile time.
|
|
|
|
bool Constant::ContainsRelocations() const {
|
|
|
|
if (isa<GlobalValue>(this))
|
|
|
|
return true;
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
|
|
|
|
if (getOperand(i)->ContainsRelocations())
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
// Static constructor to create a '0' constant of arbitrary type...
|
2002-04-27 02:25:43 +00:00
|
|
|
Constant *Constant::getNullValue(const Type *Ty) {
|
2007-09-14 22:26:36 +00:00
|
|
|
static uint64_t zero[2] = {0, 0};
|
2004-06-17 18:19:28 +00:00
|
|
|
switch (Ty->getTypeID()) {
|
2007-02-20 05:46:39 +00:00
|
|
|
case Type::IntegerTyID:
|
|
|
|
return ConstantInt::get(Ty, 0);
|
|
|
|
case Type::FloatTyID:
|
2007-09-14 22:26:36 +00:00
|
|
|
return ConstantFP::get(Ty, APFloat(APInt(32, 0)));
|
2007-02-20 05:46:39 +00:00
|
|
|
case Type::DoubleTyID:
|
2007-09-14 22:26:36 +00:00
|
|
|
return ConstantFP::get(Ty, APFloat(APInt(64, 0)));
|
2007-08-09 22:51:36 +00:00
|
|
|
case Type::X86_FP80TyID:
|
2007-09-14 22:26:36 +00:00
|
|
|
return ConstantFP::get(Ty, APFloat(APInt(80, 2, zero)));
|
2007-08-09 22:51:36 +00:00
|
|
|
case Type::FP128TyID:
|
2007-10-11 18:07:22 +00:00
|
|
|
return ConstantFP::get(Ty, APFloat(APInt(128, 2, zero), true));
|
2007-09-14 22:26:36 +00:00
|
|
|
case Type::PPC_FP128TyID:
|
|
|
|
return ConstantFP::get(Ty, APFloat(APInt(128, 2, zero)));
|
2005-04-21 23:48:37 +00:00
|
|
|
case Type::PointerTyID:
|
2001-12-03 22:26:30 +00:00
|
|
|
return ConstantPointerNull::get(cast<PointerType>(Ty));
|
2004-02-15 05:53:04 +00:00
|
|
|
case Type::StructTyID:
|
|
|
|
case Type::ArrayTyID:
|
2007-02-15 02:26:10 +00:00
|
|
|
case Type::VectorTyID:
|
2004-02-15 05:53:04 +00:00
|
|
|
return ConstantAggregateZero::get(Ty);
|
2001-06-06 20:29:01 +00:00
|
|
|
default:
|
2004-07-04 11:51:24 +00:00
|
|
|
// Function, Label, or Opaque type?
|
|
|
|
assert(!"Cannot create a null constant of that type!");
|
2001-06-06 20:29:01 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-15 06:10:53 +00:00
|
|
|
Constant *Constant::getAllOnesValue(const Type *Ty) {
|
|
|
|
if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
|
|
|
|
return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()));
|
|
|
|
return ConstantVector::getAllOnesValue(cast<VectorType>(Ty));
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-08-13 17:50:20 +00:00
|
|
|
// Static constructor to create an integral constant with all bits set
|
2007-01-11 12:24:14 +00:00
|
|
|
ConstantInt *ConstantInt::getAllOnesValue(const Type *Ty) {
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
|
2007-03-01 19:30:34 +00:00
|
|
|
return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()));
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
return 0;
|
2002-08-13 17:50:20 +00:00
|
|
|
}
|
|
|
|
|
2007-05-24 14:36:04 +00:00
|
|
|
/// @returns the value for a vector integer constant of the given type that
|
2007-01-04 01:49:26 +00:00
|
|
|
/// has all its bits set to true.
|
|
|
|
/// @brief Get the all ones value
|
2007-02-15 02:26:10 +00:00
|
|
|
ConstantVector *ConstantVector::getAllOnesValue(const VectorType *Ty) {
|
2007-01-04 01:49:26 +00:00
|
|
|
std::vector<Constant*> Elts;
|
|
|
|
Elts.resize(Ty->getNumElements(),
|
2007-01-11 12:24:14 +00:00
|
|
|
ConstantInt::getAllOnesValue(Ty->getElementType()));
|
2007-05-24 14:36:04 +00:00
|
|
|
assert(Elts[0] && "Not a vector integer type!");
|
2007-02-15 02:26:10 +00:00
|
|
|
return cast<ConstantVector>(ConstantVector::get(Elts));
|
2007-01-04 01:49:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-02-20 06:39:57 +00:00
|
|
|
// ConstantInt
|
2001-06-06 20:29:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2007-02-26 23:54:03 +00:00
|
|
|
ConstantInt::ConstantInt(const IntegerType *Ty, const APInt& V)
|
2007-02-20 05:55:46 +00:00
|
|
|
: Constant(Ty, ConstantIntVal, 0, 0), Val(V) {
|
2007-02-26 23:54:03 +00:00
|
|
|
assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2007-02-20 06:39:57 +00:00
|
|
|
ConstantInt *ConstantInt::TheTrueVal = 0;
|
|
|
|
ConstantInt *ConstantInt::TheFalseVal = 0;
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
void CleanupTrueFalse(void *) {
|
|
|
|
ConstantInt::ResetTrueFalse();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static ManagedCleanup<llvm::CleanupTrueFalse> TrueFalseCleanup;
|
|
|
|
|
|
|
|
ConstantInt *ConstantInt::CreateTrueFalseVals(bool WhichOne) {
|
|
|
|
assert(TheTrueVal == 0 && TheFalseVal == 0);
|
|
|
|
TheTrueVal = get(Type::Int1Ty, 1);
|
|
|
|
TheFalseVal = get(Type::Int1Ty, 0);
|
|
|
|
|
|
|
|
// Ensure that llvm_shutdown nulls out TheTrueVal/TheFalseVal.
|
|
|
|
TrueFalseCleanup.Register();
|
|
|
|
|
|
|
|
return WhichOne ? TheTrueVal : TheFalseVal;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
namespace {
|
2007-02-26 23:54:03 +00:00
|
|
|
struct DenseMapAPIntKeyInfo {
|
|
|
|
struct KeyTy {
|
|
|
|
APInt val;
|
|
|
|
const Type* type;
|
|
|
|
KeyTy(const APInt& V, const Type* Ty) : val(V), type(Ty) {}
|
|
|
|
KeyTy(const KeyTy& that) : val(that.val), type(that.type) {}
|
|
|
|
bool operator==(const KeyTy& that) const {
|
|
|
|
return type == that.type && this->val == that.val;
|
|
|
|
}
|
|
|
|
bool operator!=(const KeyTy& that) const {
|
|
|
|
return !this->operator==(that);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
static inline KeyTy getEmptyKey() { return KeyTy(APInt(1,0), 0); }
|
|
|
|
static inline KeyTy getTombstoneKey() { return KeyTy(APInt(1,1), 0); }
|
2007-02-20 06:39:57 +00:00
|
|
|
static unsigned getHashValue(const KeyTy &Key) {
|
2007-09-17 18:34:04 +00:00
|
|
|
return DenseMapInfo<void*>::getHashValue(Key.type) ^
|
2007-02-26 23:54:03 +00:00
|
|
|
Key.val.getHashValue();
|
2007-02-20 06:39:57 +00:00
|
|
|
}
|
2007-09-17 18:34:04 +00:00
|
|
|
static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
|
|
|
|
return LHS == RHS;
|
|
|
|
}
|
2007-08-24 00:56:33 +00:00
|
|
|
static bool isPod() { return false; }
|
2007-02-20 06:39:57 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-26 23:54:03 +00:00
|
|
|
typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt*,
|
|
|
|
DenseMapAPIntKeyInfo> IntMapTy;
|
2007-02-20 06:39:57 +00:00
|
|
|
static ManagedStatic<IntMapTy> IntConstants;
|
|
|
|
|
2007-03-19 20:39:08 +00:00
|
|
|
ConstantInt *ConstantInt::get(const Type *Ty, uint64_t V, bool isSigned) {
|
2007-02-20 06:39:57 +00:00
|
|
|
const IntegerType *ITy = cast<IntegerType>(Ty);
|
2007-03-19 20:39:08 +00:00
|
|
|
return get(APInt(ITy->getBitWidth(), V, isSigned));
|
2007-02-26 23:54:03 +00:00
|
|
|
}
|
|
|
|
|
2007-03-01 19:30:34 +00:00
|
|
|
// Get a ConstantInt from an APInt. Note that the value stored in the DenseMap
|
2008-02-07 02:30:40 +00:00
|
|
|
// as the key, is a DenseMapAPIntKeyInfo::KeyTy which has provided the
|
2007-02-26 23:54:03 +00:00
|
|
|
// 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.
|
2007-03-01 19:30:34 +00:00
|
|
|
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());
|
2007-02-26 23:54:03 +00:00
|
|
|
// get an existing value or the insertion position
|
2007-03-01 19:30:34 +00:00
|
|
|
DenseMapAPIntKeyInfo::KeyTy Key(V, ITy);
|
2007-02-26 23:54:03 +00:00
|
|
|
ConstantInt *&Slot = (*IntConstants)[Key];
|
|
|
|
// if it exists, return it.
|
|
|
|
if (Slot)
|
|
|
|
return Slot;
|
|
|
|
// otherwise create a new one, insert it, and return it.
|
2007-02-20 06:39:57 +00:00
|
|
|
return Slot = new ConstantInt(ITy, V);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2007-02-20 07:17:17 +00:00
|
|
|
// ConstantFP
|
2007-02-20 06:39:57 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2007-08-30 00:23:21 +00:00
|
|
|
ConstantFP::ConstantFP(const Type *Ty, const APFloat& V)
|
|
|
|
: Constant(Ty, ConstantFPVal, 0, 0), Val(V) {
|
|
|
|
// temporary
|
|
|
|
if (Ty==Type::FloatTy)
|
|
|
|
assert(&V.getSemantics()==&APFloat::IEEEsingle);
|
2007-09-12 03:30:33 +00:00
|
|
|
else if (Ty==Type::DoubleTy)
|
2007-08-30 00:23:21 +00:00
|
|
|
assert(&V.getSemantics()==&APFloat::IEEEdouble);
|
2007-09-12 03:30:33 +00:00
|
|
|
else if (Ty==Type::X86_FP80Ty)
|
|
|
|
assert(&V.getSemantics()==&APFloat::x87DoubleExtended);
|
|
|
|
else if (Ty==Type::FP128Ty)
|
|
|
|
assert(&V.getSemantics()==&APFloat::IEEEquad);
|
2007-10-11 18:07:22 +00:00
|
|
|
else if (Ty==Type::PPC_FP128Ty)
|
|
|
|
assert(&V.getSemantics()==&APFloat::PPCDoubleDouble);
|
2007-09-12 03:30:33 +00:00
|
|
|
else
|
|
|
|
assert(0);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2007-02-20 07:17:17 +00:00
|
|
|
bool ConstantFP::isNullValue() const {
|
2007-08-24 00:56:33 +00:00
|
|
|
return Val.isZero() && !Val.isNegative();
|
2007-02-20 07:17:17 +00:00
|
|
|
}
|
|
|
|
|
2007-09-14 22:26:36 +00:00
|
|
|
ConstantFP *ConstantFP::getNegativeZero(const Type *Ty) {
|
|
|
|
APFloat apf = cast <ConstantFP>(Constant::getNullValue(Ty))->getValueAPF();
|
|
|
|
apf.changeSign();
|
|
|
|
return ConstantFP::get(Ty, apf);
|
|
|
|
}
|
|
|
|
|
2007-08-30 00:23:21 +00:00
|
|
|
bool ConstantFP::isExactlyValue(const APFloat& V) const {
|
|
|
|
return Val.bitwiseIsEqual(V);
|
2007-02-20 07:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
2007-08-24 00:56:33 +00:00
|
|
|
struct DenseMapAPFloatKeyInfo {
|
2007-08-24 22:09:56 +00:00
|
|
|
struct KeyTy {
|
|
|
|
APFloat val;
|
|
|
|
KeyTy(const APFloat& V) : val(V){}
|
|
|
|
KeyTy(const KeyTy& that) : val(that.val) {}
|
|
|
|
bool operator==(const KeyTy& that) const {
|
|
|
|
return this->val.bitwiseIsEqual(that.val);
|
|
|
|
}
|
|
|
|
bool operator!=(const KeyTy& that) const {
|
|
|
|
return !this->operator==(that);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
static inline KeyTy getEmptyKey() {
|
|
|
|
return KeyTy(APFloat(APFloat::Bogus,1));
|
2007-08-24 00:56:33 +00:00
|
|
|
}
|
2007-08-24 22:09:56 +00:00
|
|
|
static inline KeyTy getTombstoneKey() {
|
|
|
|
return KeyTy(APFloat(APFloat::Bogus,2));
|
2007-02-26 23:54:03 +00:00
|
|
|
}
|
2007-08-24 22:09:56 +00:00
|
|
|
static unsigned getHashValue(const KeyTy &Key) {
|
|
|
|
return Key.val.getHashValue();
|
2007-02-20 07:17:17 +00:00
|
|
|
}
|
2007-09-17 18:34:04 +00:00
|
|
|
static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
|
|
|
|
return LHS == RHS;
|
|
|
|
}
|
2007-08-24 00:56:33 +00:00
|
|
|
static bool isPod() { return false; }
|
2007-02-20 07:17:17 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
//---- ConstantFP::get() implementation...
|
|
|
|
//
|
2007-08-24 22:09:56 +00:00
|
|
|
typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*,
|
2007-08-24 00:56:33 +00:00
|
|
|
DenseMapAPFloatKeyInfo> FPMapTy;
|
2007-02-20 07:17:17 +00:00
|
|
|
|
2007-08-24 00:56:33 +00:00
|
|
|
static ManagedStatic<FPMapTy> FPConstants;
|
2007-02-20 07:17:17 +00:00
|
|
|
|
2007-08-30 00:23:21 +00:00
|
|
|
ConstantFP *ConstantFP::get(const Type *Ty, const APFloat& V) {
|
|
|
|
// temporary
|
|
|
|
if (Ty==Type::FloatTy)
|
|
|
|
assert(&V.getSemantics()==&APFloat::IEEEsingle);
|
2007-09-12 03:30:33 +00:00
|
|
|
else if (Ty==Type::DoubleTy)
|
2007-08-30 00:23:21 +00:00
|
|
|
assert(&V.getSemantics()==&APFloat::IEEEdouble);
|
2007-09-12 03:30:33 +00:00
|
|
|
else if (Ty==Type::X86_FP80Ty)
|
|
|
|
assert(&V.getSemantics()==&APFloat::x87DoubleExtended);
|
|
|
|
else if (Ty==Type::FP128Ty)
|
|
|
|
assert(&V.getSemantics()==&APFloat::IEEEquad);
|
2007-10-11 18:07:22 +00:00
|
|
|
else if (Ty==Type::PPC_FP128Ty)
|
|
|
|
assert(&V.getSemantics()==&APFloat::PPCDoubleDouble);
|
2007-09-12 03:30:33 +00:00
|
|
|
else
|
|
|
|
assert(0);
|
2007-08-30 00:23:21 +00:00
|
|
|
|
|
|
|
DenseMapAPFloatKeyInfo::KeyTy Key(V);
|
|
|
|
ConstantFP *&Slot = (*FPConstants)[Key];
|
|
|
|
if (Slot) return Slot;
|
|
|
|
return Slot = new ConstantFP(Ty, V);
|
|
|
|
}
|
2007-02-20 07:17:17 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// ConstantXXX Classes
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
2001-12-03 22:26:30 +00:00
|
|
|
ConstantArray::ConstantArray(const ArrayType *T,
|
2005-01-29 00:34:39 +00:00
|
|
|
const std::vector<Constant*> &V)
|
2005-09-27 06:09:08 +00:00
|
|
|
: Constant(T, ConstantArrayVal, new Use[V.size()], V.size()) {
|
2004-09-15 02:32:15 +00:00
|
|
|
assert(V.size() == T->getNumElements() &&
|
|
|
|
"Invalid initializer vector for constant array");
|
2005-01-29 00:34:39 +00:00
|
|
|
Use *OL = OperandList;
|
2005-10-03 21:56:24 +00:00
|
|
|
for (std::vector<Constant*>::const_iterator I = V.begin(), E = V.end();
|
|
|
|
I != E; ++I, ++OL) {
|
2005-10-07 05:23:36 +00:00
|
|
|
Constant *C = *I;
|
|
|
|
assert((C->getType() == T->getElementType() ||
|
2004-09-10 04:16:59 +00:00
|
|
|
(T->isAbstract() &&
|
2005-10-07 05:23:36 +00:00
|
|
|
C->getType()->getTypeID() == T->getElementType()->getTypeID())) &&
|
2004-09-10 04:16:59 +00:00
|
|
|
"Initializer for array element doesn't match array element type!");
|
2005-10-07 05:23:36 +00:00
|
|
|
OL->init(C, this);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-10 02:14:30 +00:00
|
|
|
ConstantArray::~ConstantArray() {
|
|
|
|
delete [] OperandList;
|
2005-01-29 00:34:39 +00:00
|
|
|
}
|
|
|
|
|
2001-12-03 22:26:30 +00:00
|
|
|
ConstantStruct::ConstantStruct(const StructType *T,
|
2005-01-29 00:34:39 +00:00
|
|
|
const std::vector<Constant*> &V)
|
2005-09-27 06:09:08 +00:00
|
|
|
: Constant(T, ConstantStructVal, new Use[V.size()], V.size()) {
|
2004-02-09 04:37:31 +00:00
|
|
|
assert(V.size() == T->getNumElements() &&
|
2002-07-14 23:13:17 +00:00
|
|
|
"Invalid initializer vector for constant structure");
|
2005-01-29 00:34:39 +00:00
|
|
|
Use *OL = OperandList;
|
2005-10-03 21:56:24 +00:00
|
|
|
for (std::vector<Constant*>::const_iterator I = V.begin(), E = V.end();
|
|
|
|
I != E; ++I, ++OL) {
|
2005-10-07 05:23:36 +00:00
|
|
|
Constant *C = *I;
|
|
|
|
assert((C->getType() == T->getElementType(I-V.begin()) ||
|
2005-10-03 21:56:24 +00:00
|
|
|
((T->getElementType(I-V.begin())->isAbstract() ||
|
2005-10-07 05:23:36 +00:00
|
|
|
C->getType()->isAbstract()) &&
|
2005-10-03 21:56:24 +00:00
|
|
|
T->getElementType(I-V.begin())->getTypeID() ==
|
2005-10-07 05:23:36 +00:00
|
|
|
C->getType()->getTypeID())) &&
|
2003-06-02 17:42:47 +00:00
|
|
|
"Initializer for struct element doesn't match struct element type!");
|
2005-10-07 05:23:36 +00:00
|
|
|
OL->init(C, this);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-10 02:14:30 +00:00
|
|
|
ConstantStruct::~ConstantStruct() {
|
|
|
|
delete [] OperandList;
|
2005-01-29 00:34:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-15 02:26:10 +00:00
|
|
|
ConstantVector::ConstantVector(const VectorType *T,
|
2005-01-29 00:34:39 +00:00
|
|
|
const std::vector<Constant*> &V)
|
2007-02-15 02:26:10 +00:00
|
|
|
: Constant(T, ConstantVectorVal, new Use[V.size()], V.size()) {
|
2005-01-29 00:34:39 +00:00
|
|
|
Use *OL = OperandList;
|
2005-10-03 21:56:24 +00:00
|
|
|
for (std::vector<Constant*>::const_iterator I = V.begin(), E = V.end();
|
|
|
|
I != E; ++I, ++OL) {
|
2005-10-07 05:23:36 +00:00
|
|
|
Constant *C = *I;
|
|
|
|
assert((C->getType() == T->getElementType() ||
|
2004-09-10 04:16:59 +00:00
|
|
|
(T->isAbstract() &&
|
2005-10-07 05:23:36 +00:00
|
|
|
C->getType()->getTypeID() == T->getElementType()->getTypeID())) &&
|
2007-05-24 14:36:04 +00:00
|
|
|
"Initializer for vector element doesn't match vector element type!");
|
2005-10-07 05:23:36 +00:00
|
|
|
OL->init(C, this);
|
2004-08-20 06:00:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-10 02:14:30 +00:00
|
|
|
ConstantVector::~ConstantVector() {
|
|
|
|
delete [] OperandList;
|
2004-03-12 05:54:04 +00:00
|
|
|
}
|
|
|
|
|
2007-12-10 02:14:30 +00:00
|
|
|
// We declare several classes private to this file, so use an anonymous
|
|
|
|
// namespace
|
|
|
|
namespace {
|
2007-12-09 22:46:10 +00:00
|
|
|
|
2007-12-10 02:14:30 +00:00
|
|
|
/// 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 {
|
|
|
|
Use Op;
|
|
|
|
public:
|
|
|
|
UnaryConstantExpr(unsigned Opcode, Constant *C, const Type *Ty)
|
|
|
|
: ConstantExpr(Ty, Opcode, &Op, 1), Op(C, this) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// 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 {
|
|
|
|
Use Ops[2];
|
|
|
|
public:
|
|
|
|
BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2)
|
|
|
|
: ConstantExpr(C1->getType(), Opcode, Ops, 2) {
|
|
|
|
Ops[0].init(C1, this);
|
|
|
|
Ops[1].init(C2, this);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// 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 {
|
|
|
|
Use Ops[3];
|
|
|
|
public:
|
|
|
|
SelectConstantExpr(Constant *C1, Constant *C2, Constant *C3)
|
|
|
|
: ConstantExpr(C2->getType(), Instruction::Select, Ops, 3) {
|
|
|
|
Ops[0].init(C1, this);
|
|
|
|
Ops[1].init(C2, this);
|
|
|
|
Ops[2].init(C3, this);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// ExtractElementConstantExpr - This class is private to
|
|
|
|
/// Constants.cpp, and is used behind the scenes to implement
|
|
|
|
/// extractelement constant exprs.
|
|
|
|
class VISIBILITY_HIDDEN ExtractElementConstantExpr : public ConstantExpr {
|
|
|
|
Use Ops[2];
|
|
|
|
public:
|
|
|
|
ExtractElementConstantExpr(Constant *C1, Constant *C2)
|
|
|
|
: ConstantExpr(cast<VectorType>(C1->getType())->getElementType(),
|
|
|
|
Instruction::ExtractElement, Ops, 2) {
|
|
|
|
Ops[0].init(C1, this);
|
|
|
|
Ops[1].init(C2, this);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// InsertElementConstantExpr - This class is private to
|
|
|
|
/// Constants.cpp, and is used behind the scenes to implement
|
|
|
|
/// insertelement constant exprs.
|
|
|
|
class VISIBILITY_HIDDEN InsertElementConstantExpr : public ConstantExpr {
|
|
|
|
Use Ops[3];
|
|
|
|
public:
|
|
|
|
InsertElementConstantExpr(Constant *C1, Constant *C2, Constant *C3)
|
|
|
|
: ConstantExpr(C1->getType(), Instruction::InsertElement,
|
|
|
|
Ops, 3) {
|
|
|
|
Ops[0].init(C1, this);
|
|
|
|
Ops[1].init(C2, this);
|
|
|
|
Ops[2].init(C3, this);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// ShuffleVectorConstantExpr - This class is private to
|
|
|
|
/// Constants.cpp, and is used behind the scenes to implement
|
|
|
|
/// shufflevector constant exprs.
|
|
|
|
class VISIBILITY_HIDDEN ShuffleVectorConstantExpr : public ConstantExpr {
|
|
|
|
Use Ops[3];
|
|
|
|
public:
|
|
|
|
ShuffleVectorConstantExpr(Constant *C1, Constant *C2, Constant *C3)
|
|
|
|
: ConstantExpr(C1->getType(), Instruction::ShuffleVector,
|
|
|
|
Ops, 3) {
|
|
|
|
Ops[0].init(C1, this);
|
|
|
|
Ops[1].init(C2, this);
|
|
|
|
Ops[2].init(C3, this);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// 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 {
|
|
|
|
GetElementPtrConstantExpr(Constant *C, const std::vector<Constant*> &IdxList,
|
|
|
|
const Type *DestTy)
|
|
|
|
: ConstantExpr(DestTy, Instruction::GetElementPtr,
|
|
|
|
new Use[IdxList.size()+1], IdxList.size()+1) {
|
|
|
|
OperandList[0].init(C, this);
|
|
|
|
for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
|
|
|
|
OperandList[i+1].init(IdxList[i], this);
|
|
|
|
}
|
|
|
|
~GetElementPtrConstantExpr() {
|
|
|
|
delete [] OperandList;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// CompareConstantExpr - This class is private to Constants.cpp, and is used
|
|
|
|
// 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 {
|
|
|
|
unsigned short predicate;
|
|
|
|
Use Ops[2];
|
|
|
|
CompareConstantExpr(Instruction::OtherOps opc, unsigned short pred,
|
|
|
|
Constant* LHS, Constant* RHS)
|
|
|
|
: ConstantExpr(Type::Int1Ty, opc, Ops, 2), predicate(pred) {
|
|
|
|
OperandList[0].init(LHS, this);
|
|
|
|
OperandList[1].init(RHS, this);
|
|
|
|
}
|
|
|
|
};
|
2007-12-09 22:46:10 +00:00
|
|
|
|
2007-12-10 02:14:30 +00:00
|
|
|
} // end anonymous namespace
|
2007-12-09 22:46:10 +00:00
|
|
|
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Utility function for determining if a ConstantExpr is a CastOp or not. This
|
|
|
|
// can't be inline because we don't want to #include Instruction.h into
|
|
|
|
// Constant.h
|
|
|
|
bool ConstantExpr::isCast() const {
|
|
|
|
return Instruction::isCast(getOpcode());
|
|
|
|
}
|
|
|
|
|
2006-12-04 05:19:50 +00:00
|
|
|
bool ConstantExpr::isCompare() const {
|
|
|
|
return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp;
|
|
|
|
}
|
|
|
|
|
2004-03-29 02:37:53 +00:00
|
|
|
/// ConstantExpr::get* - Return some common constants without having to
|
|
|
|
/// specify the full Instruction::OPCODE identifier.
|
|
|
|
///
|
|
|
|
Constant *ConstantExpr::getNeg(Constant *C) {
|
2007-01-21 00:29:26 +00:00
|
|
|
return get(Instruction::Sub,
|
|
|
|
ConstantExpr::getZeroValueForNegationExpr(C->getType()),
|
|
|
|
C);
|
2004-03-29 02:37:53 +00:00
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getNot(Constant *C) {
|
2007-10-06 14:29:36 +00:00
|
|
|
assert(isa<IntegerType>(C->getType()) && "Cannot NOT a nonintegral value!");
|
2004-03-29 02:37:53 +00:00
|
|
|
return get(Instruction::Xor, C,
|
2007-01-11 12:24:14 +00:00
|
|
|
ConstantInt::getAllOnesValue(C->getType()));
|
2004-03-29 02:37:53 +00:00
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::Add, C1, C2);
|
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getSub(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::Sub, C1, C2);
|
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getMul(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::Mul, C1, C2);
|
|
|
|
}
|
2006-10-26 06:15:43 +00:00
|
|
|
Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::UDiv, C1, C2);
|
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::SDiv, C1, C2);
|
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::FDiv, C1, C2);
|
2004-03-29 02:37:53 +00:00
|
|
|
}
|
2006-11-02 01:53:59 +00:00
|
|
|
Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::URem, C1, C2);
|
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::SRem, C1, C2);
|
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::FRem, C1, C2);
|
2004-03-29 02:37:53 +00:00
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::And, C1, C2);
|
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getOr(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::Or, C1, C2);
|
|
|
|
}
|
|
|
|
Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::Xor, C1, C2);
|
|
|
|
}
|
2006-12-03 05:48:19 +00:00
|
|
|
unsigned ConstantExpr::getPredicate() const {
|
|
|
|
assert(getOpcode() == Instruction::FCmp || getOpcode() == Instruction::ICmp);
|
2007-10-18 16:26:24 +00:00
|
|
|
return ((const CompareConstantExpr*)this)->predicate;
|
2006-12-03 05:48:19 +00:00
|
|
|
}
|
2004-03-29 02:37:53 +00:00
|
|
|
Constant *ConstantExpr::getShl(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::Shl, C1, C2);
|
|
|
|
}
|
2006-11-08 06:47:33 +00:00
|
|
|
Constant *ConstantExpr::getLShr(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::LShr, C1, C2);
|
2004-03-29 02:37:53 +00:00
|
|
|
}
|
2006-11-08 06:47:33 +00:00
|
|
|
Constant *ConstantExpr::getAShr(Constant *C1, Constant *C2) {
|
|
|
|
return get(Instruction::AShr, C1, C2);
|
2004-05-25 05:32:43 +00:00
|
|
|
}
|
2001-10-03 06:12:09 +00:00
|
|
|
|
2006-07-14 19:37:40 +00:00
|
|
|
/// getWithOperandReplaced - Return a constant expression identical to this
|
|
|
|
/// one, but with the specified operand set to the specified value.
|
2006-11-27 01:05:10 +00:00
|
|
|
Constant *
|
|
|
|
ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const {
|
2006-07-14 19:37:40 +00:00
|
|
|
assert(OpNo < getNumOperands() && "Operand num is out of range!");
|
|
|
|
assert(Op->getType() == getOperand(OpNo)->getType() &&
|
|
|
|
"Replacing operand with value of different type!");
|
2006-07-14 22:20:01 +00:00
|
|
|
if (getOperand(OpNo) == Op)
|
|
|
|
return const_cast<ConstantExpr*>(this);
|
2006-07-14 19:37:40 +00:00
|
|
|
|
2006-07-14 22:20:01 +00:00
|
|
|
Constant *Op0, *Op1, *Op2;
|
2006-07-14 19:37:40 +00:00
|
|
|
switch (getOpcode()) {
|
2006-11-27 01:05:10 +00:00
|
|
|
case Instruction::Trunc:
|
|
|
|
case Instruction::ZExt:
|
|
|
|
case Instruction::SExt:
|
|
|
|
case Instruction::FPTrunc:
|
|
|
|
case Instruction::FPExt:
|
|
|
|
case Instruction::UIToFP:
|
|
|
|
case Instruction::SIToFP:
|
|
|
|
case Instruction::FPToUI:
|
|
|
|
case Instruction::FPToSI:
|
|
|
|
case Instruction::PtrToInt:
|
|
|
|
case Instruction::IntToPtr:
|
|
|
|
case Instruction::BitCast:
|
|
|
|
return ConstantExpr::getCast(getOpcode(), Op, getType());
|
2006-07-14 22:20:01 +00:00
|
|
|
case Instruction::Select:
|
|
|
|
Op0 = (OpNo == 0) ? Op : getOperand(0);
|
|
|
|
Op1 = (OpNo == 1) ? Op : getOperand(1);
|
|
|
|
Op2 = (OpNo == 2) ? Op : getOperand(2);
|
|
|
|
return ConstantExpr::getSelect(Op0, Op1, Op2);
|
|
|
|
case Instruction::InsertElement:
|
|
|
|
Op0 = (OpNo == 0) ? Op : getOperand(0);
|
|
|
|
Op1 = (OpNo == 1) ? Op : getOperand(1);
|
|
|
|
Op2 = (OpNo == 2) ? Op : getOperand(2);
|
|
|
|
return ConstantExpr::getInsertElement(Op0, Op1, Op2);
|
|
|
|
case Instruction::ExtractElement:
|
|
|
|
Op0 = (OpNo == 0) ? Op : getOperand(0);
|
|
|
|
Op1 = (OpNo == 1) ? Op : getOperand(1);
|
|
|
|
return ConstantExpr::getExtractElement(Op0, Op1);
|
|
|
|
case Instruction::ShuffleVector:
|
|
|
|
Op0 = (OpNo == 0) ? Op : getOperand(0);
|
|
|
|
Op1 = (OpNo == 1) ? Op : getOperand(1);
|
|
|
|
Op2 = (OpNo == 2) ? Op : getOperand(2);
|
|
|
|
return ConstantExpr::getShuffleVector(Op0, Op1, Op2);
|
2006-07-14 19:37:40 +00:00
|
|
|
case Instruction::GetElementPtr: {
|
2007-02-19 20:01:23 +00:00
|
|
|
SmallVector<Constant*, 8> Ops;
|
|
|
|
Ops.resize(getNumOperands());
|
2006-07-14 19:37:40 +00:00
|
|
|
for (unsigned i = 1, e = getNumOperands(); i != e; ++i)
|
2007-02-19 20:01:23 +00:00
|
|
|
Ops[i] = getOperand(i);
|
2006-07-14 19:37:40 +00:00
|
|
|
if (OpNo == 0)
|
2007-02-19 20:01:23 +00:00
|
|
|
return ConstantExpr::getGetElementPtr(Op, &Ops[0], Ops.size());
|
2006-07-14 19:37:40 +00:00
|
|
|
Ops[OpNo-1] = Op;
|
2007-02-19 20:01:23 +00:00
|
|
|
return ConstantExpr::getGetElementPtr(getOperand(0), &Ops[0], Ops.size());
|
2006-07-14 19:37:40 +00:00
|
|
|
}
|
2006-07-14 22:20:01 +00:00
|
|
|
default:
|
|
|
|
assert(getNumOperands() == 2 && "Must be binary operator?");
|
|
|
|
Op0 = (OpNo == 0) ? Op : getOperand(0);
|
|
|
|
Op1 = (OpNo == 1) ? Op : getOperand(1);
|
|
|
|
return ConstantExpr::get(getOpcode(), Op0, Op1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getWithOperands - This returns the current constant expression with the
|
|
|
|
/// operands replaced with the specified values. The specified operands must
|
|
|
|
/// match count and type with the existing ones.
|
|
|
|
Constant *ConstantExpr::
|
|
|
|
getWithOperands(const std::vector<Constant*> &Ops) const {
|
|
|
|
assert(Ops.size() == getNumOperands() && "Operand count mismatch!");
|
|
|
|
bool AnyChange = false;
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
|
|
|
|
assert(Ops[i]->getType() == getOperand(i)->getType() &&
|
|
|
|
"Operand type mismatch!");
|
|
|
|
AnyChange |= Ops[i] != getOperand(i);
|
|
|
|
}
|
|
|
|
if (!AnyChange) // No operands changed, return self.
|
|
|
|
return const_cast<ConstantExpr*>(this);
|
|
|
|
|
|
|
|
switch (getOpcode()) {
|
2006-11-27 01:05:10 +00:00
|
|
|
case Instruction::Trunc:
|
|
|
|
case Instruction::ZExt:
|
|
|
|
case Instruction::SExt:
|
|
|
|
case Instruction::FPTrunc:
|
|
|
|
case Instruction::FPExt:
|
|
|
|
case Instruction::UIToFP:
|
|
|
|
case Instruction::SIToFP:
|
|
|
|
case Instruction::FPToUI:
|
|
|
|
case Instruction::FPToSI:
|
|
|
|
case Instruction::PtrToInt:
|
|
|
|
case Instruction::IntToPtr:
|
|
|
|
case Instruction::BitCast:
|
|
|
|
return ConstantExpr::getCast(getOpcode(), Ops[0], getType());
|
2006-07-14 19:37:40 +00:00
|
|
|
case Instruction::Select:
|
2006-07-14 22:20:01 +00:00
|
|
|
return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]);
|
2006-07-14 19:37:40 +00:00
|
|
|
case Instruction::InsertElement:
|
2006-07-14 22:20:01 +00:00
|
|
|
return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]);
|
2006-07-14 19:37:40 +00:00
|
|
|
case Instruction::ExtractElement:
|
2006-07-14 22:20:01 +00:00
|
|
|
return ConstantExpr::getExtractElement(Ops[0], Ops[1]);
|
2006-07-14 19:37:40 +00:00
|
|
|
case Instruction::ShuffleVector:
|
2006-07-14 22:20:01 +00:00
|
|
|
return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]);
|
2007-02-19 20:01:23 +00:00
|
|
|
case Instruction::GetElementPtr:
|
|
|
|
return ConstantExpr::getGetElementPtr(Ops[0], &Ops[1], Ops.size()-1);
|
2006-12-23 06:05:41 +00:00
|
|
|
case Instruction::ICmp:
|
|
|
|
case Instruction::FCmp:
|
|
|
|
return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1]);
|
2006-07-14 19:37:40 +00:00
|
|
|
default:
|
|
|
|
assert(getNumOperands() == 2 && "Must be binary operator?");
|
2006-07-14 22:20:01 +00:00
|
|
|
return ConstantExpr::get(getOpcode(), Ops[0], Ops[1]);
|
2006-07-14 19:37:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// isValueValidForType implementations
|
|
|
|
|
2006-12-19 01:28:19 +00:00
|
|
|
bool ConstantInt::isValueValidForType(const Type *Ty, uint64_t Val) {
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
|
|
|
|
if (Ty == Type::Int1Ty)
|
|
|
|
return Val == 0 || Val == 1;
|
2007-02-05 23:47:56 +00:00
|
|
|
if (NumBits >= 64)
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
return true; // always true, has to fit in largest type
|
|
|
|
uint64_t Max = (1ll << NumBits) - 1;
|
|
|
|
return Val <= Max;
|
2006-12-19 01:28:19 +00:00
|
|
|
}
|
|
|
|
|
2006-10-20 07:07:24 +00:00
|
|
|
bool ConstantInt::isValueValidForType(const Type *Ty, int64_t Val) {
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
|
|
|
|
if (Ty == Type::Int1Ty)
|
2007-01-19 21:13:56 +00:00
|
|
|
return Val == 0 || Val == 1 || Val == -1;
|
2007-02-05 23:47:56 +00:00
|
|
|
if (NumBits >= 64)
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
return true; // always true, has to fit in largest type
|
|
|
|
int64_t Min = -(1ll << (NumBits-1));
|
|
|
|
int64_t Max = (1ll << (NumBits-1)) - 1;
|
|
|
|
return (Val >= Min && Val <= Max);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2007-08-30 00:23:21 +00:00
|
|
|
bool ConstantFP::isValueValidForType(const Type *Ty, const APFloat& Val) {
|
|
|
|
// convert modifies in place, so make a copy.
|
|
|
|
APFloat Val2 = APFloat(Val);
|
2004-06-17 18:19:28 +00:00
|
|
|
switch (Ty->getTypeID()) {
|
2001-06-06 20:29:01 +00:00
|
|
|
default:
|
|
|
|
return false; // These can't be represented as floating point!
|
|
|
|
|
2007-08-30 00:23:21 +00:00
|
|
|
// FIXME rounding mode needs to be more flexible
|
2001-06-06 20:29:01 +00:00
|
|
|
case Type::FloatTyID:
|
2007-08-30 00:23:21 +00:00
|
|
|
return &Val2.getSemantics() == &APFloat::IEEEsingle ||
|
|
|
|
Val2.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven) ==
|
|
|
|
APFloat::opOK;
|
2001-06-06 20:29:01 +00:00
|
|
|
case Type::DoubleTyID:
|
2007-08-30 00:23:21 +00:00
|
|
|
return &Val2.getSemantics() == &APFloat::IEEEsingle ||
|
|
|
|
&Val2.getSemantics() == &APFloat::IEEEdouble ||
|
|
|
|
Val2.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven) ==
|
|
|
|
APFloat::opOK;
|
2007-08-09 22:51:36 +00:00
|
|
|
case Type::X86_FP80TyID:
|
2007-09-12 03:30:33 +00:00
|
|
|
return &Val2.getSemantics() == &APFloat::IEEEsingle ||
|
|
|
|
&Val2.getSemantics() == &APFloat::IEEEdouble ||
|
|
|
|
&Val2.getSemantics() == &APFloat::x87DoubleExtended;
|
2007-08-09 22:51:36 +00:00
|
|
|
case Type::FP128TyID:
|
2007-09-12 03:30:33 +00:00
|
|
|
return &Val2.getSemantics() == &APFloat::IEEEsingle ||
|
|
|
|
&Val2.getSemantics() == &APFloat::IEEEdouble ||
|
|
|
|
&Val2.getSemantics() == &APFloat::IEEEquad;
|
2007-10-11 18:07:22 +00:00
|
|
|
case Type::PPC_FP128TyID:
|
|
|
|
return &Val2.getSemantics() == &APFloat::IEEEsingle ||
|
|
|
|
&Val2.getSemantics() == &APFloat::IEEEdouble ||
|
|
|
|
&Val2.getSemantics() == &APFloat::PPCDoubleDouble;
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2006-05-24 17:04:05 +00:00
|
|
|
}
|
2001-07-20 19:16:02 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2001-09-07 16:46:31 +00:00
|
|
|
// Factory Function Implementation
|
|
|
|
|
2003-05-23 20:03:32 +00:00
|
|
|
// ConstantCreator - A class that is used to create constants by
|
|
|
|
// ValueMap*. This class should be partially specialized if there is
|
|
|
|
// something strange that needs to be done to interface to the ctor for the
|
|
|
|
// constant.
|
|
|
|
//
|
2003-11-21 20:23:48 +00:00
|
|
|
namespace llvm {
|
|
|
|
template<class ConstantClass, class TypeClass, class ValType>
|
2006-06-28 21:38:54 +00:00
|
|
|
struct VISIBILITY_HIDDEN ConstantCreator {
|
2003-11-21 20:23:48 +00:00
|
|
|
static ConstantClass *create(const TypeClass *Ty, const ValType &V) {
|
|
|
|
return new ConstantClass(Ty, V);
|
|
|
|
}
|
|
|
|
};
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-11-21 20:23:48 +00:00
|
|
|
template<class ConstantClass, class TypeClass>
|
2006-06-28 21:38:54 +00:00
|
|
|
struct VISIBILITY_HIDDEN ConvertConstantType {
|
2003-11-21 20:23:48 +00:00
|
|
|
static void convert(ConstantClass *OldC, const TypeClass *NewTy) {
|
|
|
|
assert(0 && "This type cannot be converted!\n");
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
};
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2005-10-04 17:48:46 +00:00
|
|
|
template<class ValType, class TypeClass, class ConstantClass,
|
|
|
|
bool HasLargeKey = false /*true for arrays and structs*/ >
|
2006-06-28 21:38:54 +00:00
|
|
|
class VISIBILITY_HIDDEN ValueMap : public AbstractTypeUser {
|
2005-10-03 22:51:37 +00:00
|
|
|
public:
|
2006-07-17 17:38:29 +00:00
|
|
|
typedef std::pair<const Type*, ValType> MapKey;
|
|
|
|
typedef std::map<MapKey, Constant *> MapTy;
|
|
|
|
typedef std::map<Constant*, typename MapTy::iterator> InverseMapTy;
|
|
|
|
typedef std::map<const Type*, typename MapTy::iterator> AbstractTypeMapTy;
|
2005-10-03 22:51:37 +00:00
|
|
|
private:
|
2005-10-04 16:52:46 +00:00
|
|
|
/// Map - This is the main map from the element descriptor to the Constants.
|
|
|
|
/// This is the primary way we avoid creating two of the same shape
|
|
|
|
/// constant.
|
2003-10-05 00:17:43 +00:00
|
|
|
MapTy Map;
|
2005-10-04 17:48:46 +00:00
|
|
|
|
|
|
|
/// InverseMap - If "HasLargeKey" is true, this contains an inverse mapping
|
|
|
|
/// from the constants to their element in Map. This is important for
|
|
|
|
/// removal of constants from the array, which would otherwise have to scan
|
|
|
|
/// through the map with very large keys.
|
2006-07-17 17:38:29 +00:00
|
|
|
InverseMapTy InverseMap;
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2006-07-17 17:38:29 +00:00
|
|
|
/// AbstractTypeMap - Map for abstract type constants.
|
|
|
|
///
|
2003-10-05 00:17:43 +00:00
|
|
|
AbstractTypeMapTy AbstractTypeMap;
|
2004-11-19 16:39:44 +00:00
|
|
|
|
2003-05-23 20:03:32 +00:00
|
|
|
public:
|
2006-07-17 17:38:29 +00:00
|
|
|
typename MapTy::iterator map_end() { return Map.end(); }
|
2005-10-03 22:51:37 +00:00
|
|
|
|
|
|
|
/// InsertOrGetItem - Return an iterator for the specified element.
|
|
|
|
/// If the element exists in the map, the returned iterator points to the
|
|
|
|
/// entry and Exists=true. If not, the iterator points to the newly
|
|
|
|
/// inserted entry and returns Exists=false. Newly inserted entries have
|
|
|
|
/// I->second == 0, and should be filled in.
|
2006-07-17 17:38:29 +00:00
|
|
|
typename MapTy::iterator InsertOrGetItem(std::pair<MapKey, Constant *>
|
|
|
|
&InsertVal,
|
2005-10-03 22:51:37 +00:00
|
|
|
bool &Exists) {
|
2006-07-17 17:38:29 +00:00
|
|
|
std::pair<typename MapTy::iterator, bool> IP = Map.insert(InsertVal);
|
2005-10-03 22:51:37 +00:00
|
|
|
Exists = !IP.second;
|
|
|
|
return IP.first;
|
|
|
|
}
|
2005-10-04 16:52:46 +00:00
|
|
|
|
2005-10-04 17:48:46 +00:00
|
|
|
private:
|
2006-07-17 17:38:29 +00:00
|
|
|
typename MapTy::iterator FindExistingElement(ConstantClass *CP) {
|
2005-10-04 17:48:46 +00:00
|
|
|
if (HasLargeKey) {
|
2006-07-17 17:38:29 +00:00
|
|
|
typename InverseMapTy::iterator IMI = InverseMap.find(CP);
|
2005-10-04 17:48:46 +00:00
|
|
|
assert(IMI != InverseMap.end() && IMI->second != Map.end() &&
|
|
|
|
IMI->second->second == CP &&
|
|
|
|
"InverseMap corrupt!");
|
|
|
|
return IMI->second;
|
|
|
|
}
|
|
|
|
|
2006-07-17 17:38:29 +00:00
|
|
|
typename MapTy::iterator I =
|
2005-10-04 17:48:46 +00:00
|
|
|
Map.find(MapKey((TypeClass*)CP->getRawType(), getValType(CP)));
|
2005-10-04 16:52:46 +00:00
|
|
|
if (I == Map.end() || I->second != CP) {
|
|
|
|
// FIXME: This should not use a linear scan. If this gets to be a
|
|
|
|
// performance problem, someone should look at this.
|
|
|
|
for (I = Map.begin(); I != Map.end() && I->second != CP; ++I)
|
|
|
|
/* empty */;
|
|
|
|
}
|
2005-10-04 17:48:46 +00:00
|
|
|
return I;
|
|
|
|
}
|
|
|
|
public:
|
|
|
|
|
2005-10-03 22:51:37 +00:00
|
|
|
/// getOrCreate - Return the specified constant from the map, creating it if
|
|
|
|
/// necessary.
|
2003-05-23 20:03:32 +00:00
|
|
|
ConstantClass *getOrCreate(const TypeClass *Ty, const ValType &V) {
|
2003-10-05 00:17:43 +00:00
|
|
|
MapKey Lookup(Ty, V);
|
2006-07-17 17:38:29 +00:00
|
|
|
typename MapTy::iterator I = Map.lower_bound(Lookup);
|
2006-10-20 07:07:24 +00:00
|
|
|
// Is it in the map?
|
2003-05-23 20:03:32 +00:00
|
|
|
if (I != Map.end() && I->first == Lookup)
|
2006-10-20 07:07:24 +00:00
|
|
|
return static_cast<ConstantClass *>(I->second);
|
2003-05-23 20:03:32 +00:00
|
|
|
|
|
|
|
// If no preexisting value, create one now...
|
|
|
|
ConstantClass *Result =
|
|
|
|
ConstantCreator<ConstantClass,TypeClass,ValType>::create(Ty, V);
|
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
/// FIXME: why does this assert fail when loading 176.gcc?
|
|
|
|
//assert(Result->getType() == Ty && "Type specified is not correct!");
|
|
|
|
I = Map.insert(I, std::make_pair(MapKey(Ty, V), Result));
|
|
|
|
|
2005-10-04 17:48:46 +00:00
|
|
|
if (HasLargeKey) // Remember the reverse mapping if needed.
|
|
|
|
InverseMap.insert(std::make_pair(Result, I));
|
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
// If the type of the constant is abstract, make sure that an entry exists
|
|
|
|
// for it in the AbstractTypeMap.
|
|
|
|
if (Ty->isAbstract()) {
|
|
|
|
typename AbstractTypeMapTy::iterator TI =
|
|
|
|
AbstractTypeMap.lower_bound(Ty);
|
|
|
|
|
|
|
|
if (TI == AbstractTypeMap.end() || TI->first != Ty) {
|
|
|
|
// Add ourselves to the ATU list of the type.
|
|
|
|
cast<DerivedType>(Ty)->addAbstractTypeUser(this);
|
|
|
|
|
|
|
|
AbstractTypeMap.insert(TI, std::make_pair(Ty, I));
|
|
|
|
}
|
|
|
|
}
|
2003-05-23 20:03:32 +00:00
|
|
|
return Result;
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-05-23 20:03:32 +00:00
|
|
|
void remove(ConstantClass *CP) {
|
2006-07-17 17:38:29 +00:00
|
|
|
typename MapTy::iterator I = FindExistingElement(CP);
|
2003-10-05 00:17:43 +00:00
|
|
|
assert(I != Map.end() && "Constant not found in constant table!");
|
2004-08-04 04:48:01 +00:00
|
|
|
assert(I->second == CP && "Didn't find correct element?");
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2005-10-04 17:48:46 +00:00
|
|
|
if (HasLargeKey) // Remember the reverse mapping if needed.
|
|
|
|
InverseMap.erase(CP);
|
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
// Now that we found the entry, make sure this isn't the entry that
|
|
|
|
// the AbstractTypeMap points to.
|
2006-07-17 17:38:29 +00:00
|
|
|
const TypeClass *Ty = static_cast<const TypeClass *>(I->first.first);
|
2003-10-05 00:17:43 +00:00
|
|
|
if (Ty->isAbstract()) {
|
|
|
|
assert(AbstractTypeMap.count(Ty) &&
|
|
|
|
"Abstract type not in AbstractTypeMap?");
|
2006-07-17 17:38:29 +00:00
|
|
|
typename MapTy::iterator &ATMEntryIt = AbstractTypeMap[Ty];
|
2003-10-05 00:17:43 +00:00
|
|
|
if (ATMEntryIt == I) {
|
|
|
|
// Yes, we are removing the representative entry for this type.
|
|
|
|
// See if there are any other entries of the same type.
|
2006-07-17 17:38:29 +00:00
|
|
|
typename MapTy::iterator TmpIt = ATMEntryIt;
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
// First check the entry before this one...
|
|
|
|
if (TmpIt != Map.begin()) {
|
|
|
|
--TmpIt;
|
|
|
|
if (TmpIt->first.first != Ty) // Not the same type, move back...
|
|
|
|
++TmpIt;
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
// If we didn't find the same type, try to move forward...
|
|
|
|
if (TmpIt == ATMEntryIt) {
|
|
|
|
++TmpIt;
|
|
|
|
if (TmpIt == Map.end() || TmpIt->first.first != Ty)
|
|
|
|
--TmpIt; // No entry afterwards with the same type
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there is another entry in the map of the same abstract type,
|
|
|
|
// update the AbstractTypeMap entry now.
|
|
|
|
if (TmpIt != ATMEntryIt) {
|
|
|
|
ATMEntryIt = TmpIt;
|
|
|
|
} else {
|
|
|
|
// Otherwise, we are removing the last instance of this type
|
|
|
|
// from the table. Remove from the ATM, and from user list.
|
|
|
|
cast<DerivedType>(Ty)->removeAbstractTypeUser(this);
|
|
|
|
AbstractTypeMap.erase(Ty);
|
|
|
|
}
|
2003-05-23 20:03:32 +00:00
|
|
|
}
|
2003-10-05 00:17:43 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
Map.erase(I);
|
|
|
|
}
|
|
|
|
|
2005-10-04 21:35:50 +00:00
|
|
|
|
|
|
|
/// MoveConstantToNewSlot - If we are about to change C to be the element
|
|
|
|
/// specified by I, update our internal data structures to reflect this
|
|
|
|
/// fact.
|
2006-07-17 17:38:29 +00:00
|
|
|
void MoveConstantToNewSlot(ConstantClass *C, typename MapTy::iterator I) {
|
2005-10-04 21:35:50 +00:00
|
|
|
// First, remove the old location of the specified constant in the map.
|
2006-07-17 17:38:29 +00:00
|
|
|
typename MapTy::iterator OldI = FindExistingElement(C);
|
2005-10-04 21:35:50 +00:00
|
|
|
assert(OldI != Map.end() && "Constant not found in constant table!");
|
|
|
|
assert(OldI->second == C && "Didn't find correct element?");
|
|
|
|
|
|
|
|
// If this constant is the representative element for its abstract type,
|
|
|
|
// update the AbstractTypeMap so that the representative element is I.
|
|
|
|
if (C->getType()->isAbstract()) {
|
|
|
|
typename AbstractTypeMapTy::iterator ATI =
|
|
|
|
AbstractTypeMap.find(C->getType());
|
|
|
|
assert(ATI != AbstractTypeMap.end() &&
|
|
|
|
"Abstract type not in AbstractTypeMap?");
|
|
|
|
if (ATI->second == OldI)
|
|
|
|
ATI->second = I;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the old entry from the map.
|
|
|
|
Map.erase(OldI);
|
|
|
|
|
|
|
|
// Update the inverse map so that we know that this constant is now
|
|
|
|
// located at descriptor I.
|
|
|
|
if (HasLargeKey) {
|
|
|
|
assert(I->second == C && "Bad inversemap entry!");
|
|
|
|
InverseMap[C] = I;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
|
2005-04-21 23:48:37 +00:00
|
|
|
typename AbstractTypeMapTy::iterator I =
|
2006-07-17 17:38:29 +00:00
|
|
|
AbstractTypeMap.find(cast<Type>(OldTy));
|
2003-10-05 00:17:43 +00:00
|
|
|
|
|
|
|
assert(I != AbstractTypeMap.end() &&
|
|
|
|
"Abstract type not in AbstractTypeMap?");
|
|
|
|
|
|
|
|
// Convert a constant at a time until the last one is gone. The last one
|
|
|
|
// leaving will remove() itself, causing the AbstractTypeMapEntry to be
|
|
|
|
// eliminated eventually.
|
|
|
|
do {
|
|
|
|
ConvertConstantType<ConstantClass,
|
2006-07-17 17:38:29 +00:00
|
|
|
TypeClass>::convert(
|
|
|
|
static_cast<ConstantClass *>(I->second->second),
|
2003-10-05 00:17:43 +00:00
|
|
|
cast<TypeClass>(NewTy));
|
|
|
|
|
2006-07-17 17:38:29 +00:00
|
|
|
I = AbstractTypeMap.find(cast<Type>(OldTy));
|
2003-10-05 00:17:43 +00:00
|
|
|
} while (I != AbstractTypeMap.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the type became concrete without being refined to any other existing
|
|
|
|
// type, we just remove ourselves from the ATU list.
|
|
|
|
void typeBecameConcrete(const DerivedType *AbsTy) {
|
|
|
|
AbsTy->removeAbstractTypeUser(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void dump() const {
|
2006-11-17 08:03:48 +00:00
|
|
|
DOUT << "Constant.cpp: ValueMap\n";
|
2003-05-23 20:03:32 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2001-09-07 16:46:31 +00:00
|
|
|
|
2006-09-28 23:36:21 +00:00
|
|
|
|
2007-02-20 06:11:36 +00:00
|
|
|
|
2004-02-15 05:53:04 +00:00
|
|
|
//---- ConstantAggregateZero::get() implementation...
|
|
|
|
//
|
|
|
|
namespace llvm {
|
|
|
|
// ConstantAggregateZero does not take extra "value" argument...
|
|
|
|
template<class ValType>
|
|
|
|
struct ConstantCreator<ConstantAggregateZero, Type, ValType> {
|
|
|
|
static ConstantAggregateZero *create(const Type *Ty, const ValType &V){
|
|
|
|
return new ConstantAggregateZero(Ty);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
|
|
|
struct ConvertConstantType<ConstantAggregateZero, Type> {
|
|
|
|
static void convert(ConstantAggregateZero *OldC, const Type *NewTy) {
|
|
|
|
// Make everyone now use a constant of the new type...
|
|
|
|
Constant *New = ConstantAggregateZero::get(NewTy);
|
|
|
|
assert(New != OldC && "Didn't replace constant??");
|
|
|
|
OldC->uncheckedReplaceAllUsesWith(New);
|
|
|
|
OldC->destroyConstant(); // This constant is now dead, destroy it.
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2006-09-28 00:35:06 +00:00
|
|
|
static ManagedStatic<ValueMap<char, Type,
|
|
|
|
ConstantAggregateZero> > AggZeroConstants;
|
2004-02-15 05:53:04 +00:00
|
|
|
|
2004-08-04 04:48:01 +00:00
|
|
|
static char getValType(ConstantAggregateZero *CPZ) { return 0; }
|
|
|
|
|
2004-02-15 05:53:04 +00:00
|
|
|
Constant *ConstantAggregateZero::get(const Type *Ty) {
|
2007-02-15 02:26:10 +00:00
|
|
|
assert((isa<StructType>(Ty) || isa<ArrayType>(Ty) || isa<VectorType>(Ty)) &&
|
2006-06-10 04:16:23 +00:00
|
|
|
"Cannot create an aggregate zero of non-aggregate type!");
|
2006-09-28 00:35:06 +00:00
|
|
|
return AggZeroConstants->getOrCreate(Ty, 0);
|
2004-02-15 05:53:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// destroyConstant - Remove the constant from the constant table...
|
|
|
|
//
|
|
|
|
void ConstantAggregateZero::destroyConstant() {
|
2006-09-28 00:35:06 +00:00
|
|
|
AggZeroConstants->remove(this);
|
2004-02-15 05:53:04 +00:00
|
|
|
destroyConstantImpl();
|
|
|
|
}
|
|
|
|
|
2001-12-03 22:26:30 +00:00
|
|
|
//---- ConstantArray::get() implementation...
|
2001-09-07 16:46:31 +00:00
|
|
|
//
|
2003-11-21 20:23:48 +00:00
|
|
|
namespace llvm {
|
|
|
|
template<>
|
|
|
|
struct ConvertConstantType<ConstantArray, ArrayType> {
|
|
|
|
static void convert(ConstantArray *OldC, const ArrayType *NewTy) {
|
|
|
|
// Make everyone now use a constant of the new type...
|
|
|
|
std::vector<Constant*> C;
|
|
|
|
for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
|
|
|
|
C.push_back(cast<Constant>(OldC->getOperand(i)));
|
|
|
|
Constant *New = ConstantArray::get(NewTy, C);
|
|
|
|
assert(New != OldC && "Didn't replace constant??");
|
|
|
|
OldC->uncheckedReplaceAllUsesWith(New);
|
|
|
|
OldC->destroyConstant(); // This constant is now dead, destroy it.
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2004-08-04 04:48:01 +00:00
|
|
|
static std::vector<Constant*> getValType(ConstantArray *CA) {
|
|
|
|
std::vector<Constant*> Elements;
|
|
|
|
Elements.reserve(CA->getNumOperands());
|
|
|
|
for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i)
|
|
|
|
Elements.push_back(cast<Constant>(CA->getOperand(i)));
|
|
|
|
return Elements;
|
|
|
|
}
|
|
|
|
|
2005-10-03 22:51:37 +00:00
|
|
|
typedef ValueMap<std::vector<Constant*>, ArrayType,
|
2005-10-04 17:48:46 +00:00
|
|
|
ConstantArray, true /*largekey*/> ArrayConstantsTy;
|
2006-09-28 00:35:06 +00:00
|
|
|
static ManagedStatic<ArrayConstantsTy> ArrayConstants;
|
2001-09-07 16:46:31 +00:00
|
|
|
|
2004-02-15 04:14:47 +00:00
|
|
|
Constant *ConstantArray::get(const ArrayType *Ty,
|
2004-02-15 05:53:04 +00:00
|
|
|
const std::vector<Constant*> &V) {
|
|
|
|
// If this is an all-zero array, return a ConstantAggregateZero object
|
|
|
|
if (!V.empty()) {
|
|
|
|
Constant *C = V[0];
|
|
|
|
if (!C->isNullValue())
|
2006-09-28 00:35:06 +00:00
|
|
|
return ArrayConstants->getOrCreate(Ty, V);
|
2004-02-15 05:53:04 +00:00
|
|
|
for (unsigned i = 1, e = V.size(); i != e; ++i)
|
|
|
|
if (V[i] != C)
|
2006-09-28 00:35:06 +00:00
|
|
|
return ArrayConstants->getOrCreate(Ty, V);
|
2004-02-15 05:53:04 +00:00
|
|
|
}
|
|
|
|
return ConstantAggregateZero::get(Ty);
|
2001-09-07 16:46:31 +00:00
|
|
|
}
|
|
|
|
|
2003-05-23 20:03:32 +00:00
|
|
|
// destroyConstant - Remove the constant from the constant table...
|
|
|
|
//
|
|
|
|
void ConstantArray::destroyConstant() {
|
2006-09-28 00:35:06 +00:00
|
|
|
ArrayConstants->remove(this);
|
2003-05-23 20:03:32 +00:00
|
|
|
destroyConstantImpl();
|
|
|
|
}
|
|
|
|
|
2006-05-30 08:23:18 +00:00
|
|
|
/// ConstantArray::get(const string&) - Return an array that is initialized to
|
|
|
|
/// contain the specified string. If length is zero then a null terminator is
|
|
|
|
/// added to the specified string so that it may be used in a natural way.
|
|
|
|
/// Otherwise, the length parameter specifies how much of the string to use
|
|
|
|
/// and it won't be null terminated.
|
|
|
|
///
|
2006-05-30 18:15:07 +00:00
|
|
|
Constant *ConstantArray::get(const std::string &Str, bool AddNull) {
|
2002-01-20 22:54:45 +00:00
|
|
|
std::vector<Constant*> ElementVals;
|
2006-05-30 18:15:07 +00:00
|
|
|
for (unsigned i = 0; i < Str.length(); ++i)
|
2006-12-31 05:26:44 +00:00
|
|
|
ElementVals.push_back(ConstantInt::get(Type::Int8Ty, Str[i]));
|
2001-10-14 23:54:12 +00:00
|
|
|
|
|
|
|
// Add a null terminator to the string...
|
2006-05-30 18:15:07 +00:00
|
|
|
if (AddNull) {
|
2006-12-31 05:26:44 +00:00
|
|
|
ElementVals.push_back(ConstantInt::get(Type::Int8Ty, 0));
|
2006-05-30 08:23:18 +00:00
|
|
|
}
|
2001-10-14 23:54:12 +00:00
|
|
|
|
2006-12-31 05:26:44 +00:00
|
|
|
ArrayType *ATy = ArrayType::get(Type::Int8Ty, ElementVals.size());
|
2001-12-03 22:26:30 +00:00
|
|
|
return ConstantArray::get(ATy, ElementVals);
|
2001-10-14 23:17:20 +00:00
|
|
|
}
|
|
|
|
|
2007-01-26 07:37:34 +00:00
|
|
|
/// isString - This method returns true if the array is an array of i8, and
|
|
|
|
/// if the elements of the array are all ConstantInt's.
|
2004-01-14 17:06:38 +00:00
|
|
|
bool ConstantArray::isString() const {
|
2007-01-26 07:37:34 +00:00
|
|
|
// Check the element type for i8...
|
2006-12-31 05:26:44 +00:00
|
|
|
if (getType()->getElementType() != Type::Int8Ty)
|
2004-01-14 17:06:38 +00:00
|
|
|
return false;
|
|
|
|
// Check the elements to make sure they are all integers, not constant
|
|
|
|
// expressions.
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
|
|
|
|
if (!isa<ConstantInt>(getOperand(i)))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2006-10-26 19:15:05 +00:00
|
|
|
/// isCString - This method returns true if the array is a string (see
|
|
|
|
/// isString) and it ends in a null byte \0 and does not contains any other
|
|
|
|
/// null bytes except its terminator.
|
|
|
|
bool ConstantArray::isCString() const {
|
2007-01-26 07:37:34 +00:00
|
|
|
// Check the element type for i8...
|
2006-12-31 05:26:44 +00:00
|
|
|
if (getType()->getElementType() != Type::Int8Ty)
|
2006-10-26 21:48:03 +00:00
|
|
|
return false;
|
|
|
|
Constant *Zero = Constant::getNullValue(getOperand(0)->getType());
|
|
|
|
// Last element must be a null.
|
|
|
|
if (getOperand(getNumOperands()-1) != Zero)
|
|
|
|
return false;
|
|
|
|
// Other elements must be non-null integers.
|
|
|
|
for (unsigned i = 0, e = getNumOperands()-1; i != e; ++i) {
|
|
|
|
if (!isa<ConstantInt>(getOperand(i)))
|
2006-10-26 19:15:05 +00:00
|
|
|
return false;
|
2006-10-26 21:48:03 +00:00
|
|
|
if (getOperand(i) == Zero)
|
|
|
|
return false;
|
|
|
|
}
|
2006-10-26 19:15:05 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-01-26 07:37:34 +00:00
|
|
|
// getAsString - If the sub-element type of this array is i8
|
2002-08-26 17:53:56 +00:00
|
|
|
// then this method converts the array to an std::string and returns it.
|
|
|
|
// Otherwise, it asserts out.
|
|
|
|
//
|
|
|
|
std::string ConstantArray::getAsString() const {
|
2004-01-14 17:06:38 +00:00
|
|
|
assert(isString() && "Not a string!");
|
2002-08-26 17:53:56 +00:00
|
|
|
std::string Result;
|
2003-07-23 15:22:26 +00:00
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
|
2006-10-20 07:07:24 +00:00
|
|
|
Result += (char)cast<ConstantInt>(getOperand(i))->getZExtValue();
|
2002-08-26 17:53:56 +00:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-12-03 22:26:30 +00:00
|
|
|
//---- ConstantStruct::get() implementation...
|
2001-09-07 16:46:31 +00:00
|
|
|
//
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2003-11-21 20:23:48 +00:00
|
|
|
namespace llvm {
|
|
|
|
template<>
|
|
|
|
struct ConvertConstantType<ConstantStruct, StructType> {
|
|
|
|
static void convert(ConstantStruct *OldC, const StructType *NewTy) {
|
|
|
|
// Make everyone now use a constant of the new type...
|
|
|
|
std::vector<Constant*> C;
|
|
|
|
for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
|
|
|
|
C.push_back(cast<Constant>(OldC->getOperand(i)));
|
|
|
|
Constant *New = ConstantStruct::get(NewTy, C);
|
|
|
|
assert(New != OldC && "Didn't replace constant??");
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-11-21 20:23:48 +00:00
|
|
|
OldC->uncheckedReplaceAllUsesWith(New);
|
|
|
|
OldC->destroyConstant(); // This constant is now dead, destroy it.
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2005-10-04 01:17:50 +00:00
|
|
|
typedef ValueMap<std::vector<Constant*>, StructType,
|
2005-10-04 17:48:46 +00:00
|
|
|
ConstantStruct, true /*largekey*/> StructConstantsTy;
|
2006-09-28 00:35:06 +00:00
|
|
|
static ManagedStatic<StructConstantsTy> StructConstants;
|
2001-09-07 16:46:31 +00:00
|
|
|
|
2004-08-04 04:48:01 +00:00
|
|
|
static std::vector<Constant*> getValType(ConstantStruct *CS) {
|
|
|
|
std::vector<Constant*> Elements;
|
|
|
|
Elements.reserve(CS->getNumOperands());
|
|
|
|
for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i)
|
|
|
|
Elements.push_back(cast<Constant>(CS->getOperand(i)));
|
|
|
|
return Elements;
|
|
|
|
}
|
|
|
|
|
2004-02-15 04:14:47 +00:00
|
|
|
Constant *ConstantStruct::get(const StructType *Ty,
|
|
|
|
const std::vector<Constant*> &V) {
|
2004-02-15 05:53:04 +00:00
|
|
|
// Create a ConstantAggregateZero value if all elements are zeros...
|
|
|
|
for (unsigned i = 0, e = V.size(); i != e; ++i)
|
|
|
|
if (!V[i]->isNullValue())
|
2006-09-28 00:35:06 +00:00
|
|
|
return StructConstants->getOrCreate(Ty, V);
|
2004-02-15 05:53:04 +00:00
|
|
|
|
|
|
|
return ConstantAggregateZero::get(Ty);
|
2001-09-07 16:46:31 +00:00
|
|
|
}
|
2001-10-03 15:39:36 +00:00
|
|
|
|
2006-12-08 18:06:16 +00:00
|
|
|
Constant *ConstantStruct::get(const std::vector<Constant*> &V, bool packed) {
|
2004-07-12 20:35:11 +00:00
|
|
|
std::vector<const Type*> StructEls;
|
|
|
|
StructEls.reserve(V.size());
|
|
|
|
for (unsigned i = 0, e = V.size(); i != e; ++i)
|
|
|
|
StructEls.push_back(V[i]->getType());
|
2006-12-08 18:06:16 +00:00
|
|
|
return get(StructType::get(StructEls, packed), V);
|
2004-07-12 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
2001-10-13 06:57:33 +00:00
|
|
|
// destroyConstant - Remove the constant from the constant table...
|
|
|
|
//
|
2001-12-03 22:26:30 +00:00
|
|
|
void ConstantStruct::destroyConstant() {
|
2006-09-28 00:35:06 +00:00
|
|
|
StructConstants->remove(this);
|
2001-10-13 06:57:33 +00:00
|
|
|
destroyConstantImpl();
|
|
|
|
}
|
|
|
|
|
2007-02-15 02:26:10 +00:00
|
|
|
//---- ConstantVector::get() implementation...
|
2004-08-20 06:00:58 +00:00
|
|
|
//
|
|
|
|
namespace llvm {
|
|
|
|
template<>
|
2007-02-15 02:26:10 +00:00
|
|
|
struct ConvertConstantType<ConstantVector, VectorType> {
|
|
|
|
static void convert(ConstantVector *OldC, const VectorType *NewTy) {
|
2004-08-20 06:00:58 +00:00
|
|
|
// Make everyone now use a constant of the new type...
|
|
|
|
std::vector<Constant*> C;
|
|
|
|
for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
|
|
|
|
C.push_back(cast<Constant>(OldC->getOperand(i)));
|
2007-02-15 02:26:10 +00:00
|
|
|
Constant *New = ConstantVector::get(NewTy, C);
|
2004-08-20 06:00:58 +00:00
|
|
|
assert(New != OldC && "Didn't replace constant??");
|
|
|
|
OldC->uncheckedReplaceAllUsesWith(New);
|
|
|
|
OldC->destroyConstant(); // This constant is now dead, destroy it.
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2007-02-15 02:26:10 +00:00
|
|
|
static std::vector<Constant*> getValType(ConstantVector *CP) {
|
2004-08-20 06:00:58 +00:00
|
|
|
std::vector<Constant*> Elements;
|
|
|
|
Elements.reserve(CP->getNumOperands());
|
|
|
|
for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
|
|
|
|
Elements.push_back(CP->getOperand(i));
|
|
|
|
return Elements;
|
|
|
|
}
|
|
|
|
|
2007-02-15 02:26:10 +00:00
|
|
|
static ManagedStatic<ValueMap<std::vector<Constant*>, VectorType,
|
2007-02-15 03:39:18 +00:00
|
|
|
ConstantVector> > VectorConstants;
|
2004-08-20 06:00:58 +00:00
|
|
|
|
2007-02-15 02:26:10 +00:00
|
|
|
Constant *ConstantVector::get(const VectorType *Ty,
|
2004-08-20 06:00:58 +00:00
|
|
|
const std::vector<Constant*> &V) {
|
2007-05-24 14:36:04 +00:00
|
|
|
// If this is an all-zero vector, return a ConstantAggregateZero object
|
2004-08-20 06:00:58 +00:00
|
|
|
if (!V.empty()) {
|
|
|
|
Constant *C = V[0];
|
|
|
|
if (!C->isNullValue())
|
2007-02-15 03:39:18 +00:00
|
|
|
return VectorConstants->getOrCreate(Ty, V);
|
2004-08-20 06:00:58 +00:00
|
|
|
for (unsigned i = 1, e = V.size(); i != e; ++i)
|
|
|
|
if (V[i] != C)
|
2007-02-15 03:39:18 +00:00
|
|
|
return VectorConstants->getOrCreate(Ty, V);
|
2004-08-20 06:00:58 +00:00
|
|
|
}
|
|
|
|
return ConstantAggregateZero::get(Ty);
|
|
|
|
}
|
|
|
|
|
2007-02-15 02:26:10 +00:00
|
|
|
Constant *ConstantVector::get(const std::vector<Constant*> &V) {
|
2004-08-20 06:00:58 +00:00
|
|
|
assert(!V.empty() && "Cannot infer type if V is empty");
|
2007-02-15 02:26:10 +00:00
|
|
|
return get(VectorType::get(V.front()->getType(),V.size()), V);
|
2004-08-20 06:00:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// destroyConstant - Remove the constant from the constant table...
|
|
|
|
//
|
2007-02-15 02:26:10 +00:00
|
|
|
void ConstantVector::destroyConstant() {
|
2007-02-15 03:39:18 +00:00
|
|
|
VectorConstants->remove(this);
|
2004-08-20 06:00:58 +00:00
|
|
|
destroyConstantImpl();
|
|
|
|
}
|
|
|
|
|
2007-05-24 14:36:04 +00:00
|
|
|
/// This function will return true iff every element in this vector constant
|
2007-01-12 22:39:14 +00:00
|
|
|
/// is set to all ones.
|
|
|
|
/// @returns true iff this constant's emements are all set to all ones.
|
|
|
|
/// @brief Determine if the value is all ones.
|
2007-02-15 02:26:10 +00:00
|
|
|
bool ConstantVector::isAllOnesValue() const {
|
2007-01-12 22:39:14 +00:00
|
|
|
// Check out first element.
|
|
|
|
const Constant *Elt = getOperand(0);
|
|
|
|
const ConstantInt *CI = dyn_cast<ConstantInt>(Elt);
|
|
|
|
if (!CI || !CI->isAllOnesValue()) return false;
|
|
|
|
// Then make sure all remaining elements point to the same value.
|
|
|
|
for (unsigned I = 1, E = getNumOperands(); I < E; ++I) {
|
|
|
|
if (getOperand(I) != Elt) return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-10-17 17:51:30 +00:00
|
|
|
/// getSplatValue - If this is a splat constant, where all of the
|
|
|
|
/// elements have the same value, return that value. Otherwise return null.
|
|
|
|
Constant *ConstantVector::getSplatValue() {
|
|
|
|
// Check out first element.
|
|
|
|
Constant *Elt = getOperand(0);
|
|
|
|
// Then make sure all remaining elements point to the same value.
|
|
|
|
for (unsigned I = 1, E = getNumOperands(); I < E; ++I)
|
|
|
|
if (getOperand(I) != Elt) return 0;
|
|
|
|
return Elt;
|
|
|
|
}
|
|
|
|
|
2001-12-03 22:26:30 +00:00
|
|
|
//---- ConstantPointerNull::get() implementation...
|
2001-10-03 15:39:36 +00:00
|
|
|
//
|
2003-05-23 20:03:32 +00:00
|
|
|
|
2003-11-21 20:23:48 +00:00
|
|
|
namespace llvm {
|
|
|
|
// ConstantPointerNull does not take extra "value" argument...
|
|
|
|
template<class ValType>
|
|
|
|
struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
|
|
|
|
static ConstantPointerNull *create(const PointerType *Ty, const ValType &V){
|
|
|
|
return new ConstantPointerNull(Ty);
|
|
|
|
}
|
|
|
|
};
|
2003-05-23 20:03:32 +00:00
|
|
|
|
2003-11-21 20:23:48 +00:00
|
|
|
template<>
|
|
|
|
struct ConvertConstantType<ConstantPointerNull, PointerType> {
|
|
|
|
static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) {
|
|
|
|
// Make everyone now use a constant of the new type...
|
|
|
|
Constant *New = ConstantPointerNull::get(NewTy);
|
|
|
|
assert(New != OldC && "Didn't replace constant??");
|
|
|
|
OldC->uncheckedReplaceAllUsesWith(New);
|
|
|
|
OldC->destroyConstant(); // This constant is now dead, destroy it.
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2006-09-28 00:35:06 +00:00
|
|
|
static ManagedStatic<ValueMap<char, PointerType,
|
|
|
|
ConstantPointerNull> > NullPtrConstants;
|
2001-10-03 15:39:36 +00:00
|
|
|
|
2004-08-04 04:48:01 +00:00
|
|
|
static char getValType(ConstantPointerNull *) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-12-03 22:26:30 +00:00
|
|
|
ConstantPointerNull *ConstantPointerNull::get(const PointerType *Ty) {
|
2006-09-28 00:35:06 +00:00
|
|
|
return NullPtrConstants->getOrCreate(Ty, 0);
|
2001-10-03 15:39:36 +00:00
|
|
|
}
|
|
|
|
|
2002-08-18 00:40:04 +00:00
|
|
|
// destroyConstant - Remove the constant from the constant table...
|
|
|
|
//
|
|
|
|
void ConstantPointerNull::destroyConstant() {
|
2006-09-28 00:35:06 +00:00
|
|
|
NullPtrConstants->remove(this);
|
2002-08-18 00:40:04 +00:00
|
|
|
destroyConstantImpl();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-10-16 18:07:16 +00:00
|
|
|
//---- UndefValue::get() implementation...
|
|
|
|
//
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
// UndefValue does not take extra "value" argument...
|
|
|
|
template<class ValType>
|
|
|
|
struct ConstantCreator<UndefValue, Type, ValType> {
|
|
|
|
static UndefValue *create(const Type *Ty, const ValType &V) {
|
|
|
|
return new UndefValue(Ty);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
|
|
|
struct ConvertConstantType<UndefValue, Type> {
|
|
|
|
static void convert(UndefValue *OldC, const Type *NewTy) {
|
|
|
|
// Make everyone now use a constant of the new type.
|
|
|
|
Constant *New = UndefValue::get(NewTy);
|
|
|
|
assert(New != OldC && "Didn't replace constant??");
|
|
|
|
OldC->uncheckedReplaceAllUsesWith(New);
|
|
|
|
OldC->destroyConstant(); // This constant is now dead, destroy it.
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2006-09-28 00:35:06 +00:00
|
|
|
static ManagedStatic<ValueMap<char, Type, UndefValue> > UndefValueConstants;
|
2004-10-16 18:07:16 +00:00
|
|
|
|
|
|
|
static char getValType(UndefValue *) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
UndefValue *UndefValue::get(const Type *Ty) {
|
2006-09-28 00:35:06 +00:00
|
|
|
return UndefValueConstants->getOrCreate(Ty, 0);
|
2004-10-16 18:07:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// destroyConstant - Remove the constant from the constant table.
|
|
|
|
//
|
|
|
|
void UndefValue::destroyConstant() {
|
2006-09-28 00:35:06 +00:00
|
|
|
UndefValueConstants->remove(this);
|
2004-10-16 18:07:16 +00:00
|
|
|
destroyConstantImpl();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-07-14 23:13:17 +00:00
|
|
|
//---- ConstantExpr::get() implementations...
|
|
|
|
//
|
2006-12-31 05:26:44 +00:00
|
|
|
|
2006-12-04 05:19:50 +00:00
|
|
|
struct ExprMapKeyType {
|
|
|
|
explicit ExprMapKeyType(unsigned opc, std::vector<Constant*> ops,
|
2006-12-04 18:38:05 +00:00
|
|
|
unsigned short pred = 0) : opcode(opc), predicate(pred), operands(ops) { }
|
|
|
|
uint16_t opcode;
|
|
|
|
uint16_t predicate;
|
2006-12-04 05:19:50 +00:00
|
|
|
std::vector<Constant*> operands;
|
|
|
|
bool operator==(const ExprMapKeyType& that) const {
|
|
|
|
return this->opcode == that.opcode &&
|
|
|
|
this->predicate == that.predicate &&
|
|
|
|
this->operands == that.operands;
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator!=(const ExprMapKeyType& that) const {
|
|
|
|
return !(*this == that);
|
|
|
|
}
|
|
|
|
};
|
2003-05-23 20:03:32 +00:00
|
|
|
|
2003-11-21 20:23:48 +00:00
|
|
|
namespace llvm {
|
|
|
|
template<>
|
|
|
|
struct ConstantCreator<ConstantExpr, Type, ExprMapKeyType> {
|
2006-12-03 05:48:19 +00:00
|
|
|
static ConstantExpr *create(const Type *Ty, const ExprMapKeyType &V,
|
|
|
|
unsigned short pred = 0) {
|
2006-12-04 05:19:50 +00:00
|
|
|
if (Instruction::isCast(V.opcode))
|
|
|
|
return new UnaryConstantExpr(V.opcode, V.operands[0], Ty);
|
|
|
|
if ((V.opcode >= Instruction::BinaryOpsBegin &&
|
2007-02-02 02:16:23 +00:00
|
|
|
V.opcode < Instruction::BinaryOpsEnd))
|
2006-12-04 05:19:50 +00:00
|
|
|
return new BinaryConstantExpr(V.opcode, V.operands[0], V.operands[1]);
|
|
|
|
if (V.opcode == Instruction::Select)
|
|
|
|
return new SelectConstantExpr(V.operands[0], V.operands[1],
|
|
|
|
V.operands[2]);
|
|
|
|
if (V.opcode == Instruction::ExtractElement)
|
|
|
|
return new ExtractElementConstantExpr(V.operands[0], V.operands[1]);
|
|
|
|
if (V.opcode == Instruction::InsertElement)
|
|
|
|
return new InsertElementConstantExpr(V.operands[0], V.operands[1],
|
|
|
|
V.operands[2]);
|
|
|
|
if (V.opcode == Instruction::ShuffleVector)
|
|
|
|
return new ShuffleVectorConstantExpr(V.operands[0], V.operands[1],
|
|
|
|
V.operands[2]);
|
|
|
|
if (V.opcode == Instruction::GetElementPtr) {
|
|
|
|
std::vector<Constant*> IdxList(V.operands.begin()+1, V.operands.end());
|
|
|
|
return new GetElementPtrConstantExpr(V.operands[0], IdxList, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
// The compare instructions are weird. We have to encode the predicate
|
|
|
|
// value and it is combined with the instruction opcode by multiplying
|
|
|
|
// the opcode by one hundred. We must decode this to get the predicate.
|
|
|
|
if (V.opcode == Instruction::ICmp)
|
|
|
|
return new CompareConstantExpr(Instruction::ICmp, V.predicate,
|
|
|
|
V.operands[0], V.operands[1]);
|
|
|
|
if (V.opcode == Instruction::FCmp)
|
|
|
|
return new CompareConstantExpr(Instruction::FCmp, V.predicate,
|
|
|
|
V.operands[0], V.operands[1]);
|
|
|
|
assert(0 && "Invalid ConstantExpr!");
|
2006-12-15 21:47:01 +00:00
|
|
|
return 0;
|
2003-11-21 20:23:48 +00:00
|
|
|
}
|
|
|
|
};
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2003-11-21 20:23:48 +00:00
|
|
|
template<>
|
|
|
|
struct ConvertConstantType<ConstantExpr, Type> {
|
|
|
|
static void convert(ConstantExpr *OldC, const Type *NewTy) {
|
|
|
|
Constant *New;
|
|
|
|
switch (OldC->getOpcode()) {
|
2006-11-27 01:05:10 +00:00
|
|
|
case Instruction::Trunc:
|
|
|
|
case Instruction::ZExt:
|
|
|
|
case Instruction::SExt:
|
|
|
|
case Instruction::FPTrunc:
|
|
|
|
case Instruction::FPExt:
|
|
|
|
case Instruction::UIToFP:
|
|
|
|
case Instruction::SIToFP:
|
|
|
|
case Instruction::FPToUI:
|
|
|
|
case Instruction::FPToSI:
|
|
|
|
case Instruction::PtrToInt:
|
|
|
|
case Instruction::IntToPtr:
|
|
|
|
case Instruction::BitCast:
|
2006-12-12 23:36:14 +00:00
|
|
|
New = ConstantExpr::getCast(OldC->getOpcode(), OldC->getOperand(0),
|
|
|
|
NewTy);
|
2003-11-21 20:23:48 +00:00
|
|
|
break;
|
2004-03-12 05:54:04 +00:00
|
|
|
case Instruction::Select:
|
|
|
|
New = ConstantExpr::getSelectTy(NewTy, OldC->getOperand(0),
|
|
|
|
OldC->getOperand(1),
|
|
|
|
OldC->getOperand(2));
|
|
|
|
break;
|
2003-11-21 20:23:48 +00:00
|
|
|
default:
|
|
|
|
assert(OldC->getOpcode() >= Instruction::BinaryOpsBegin &&
|
2006-11-02 01:53:59 +00:00
|
|
|
OldC->getOpcode() < Instruction::BinaryOpsEnd);
|
2003-11-21 20:23:48 +00:00
|
|
|
New = ConstantExpr::getTy(NewTy, OldC->getOpcode(), OldC->getOperand(0),
|
|
|
|
OldC->getOperand(1));
|
|
|
|
break;
|
|
|
|
case Instruction::GetElementPtr:
|
2005-04-21 23:48:37 +00:00
|
|
|
// Make everyone now use a constant of the new type...
|
2004-10-11 22:52:25 +00:00
|
|
|
std::vector<Value*> Idx(OldC->op_begin()+1, OldC->op_end());
|
2007-01-31 04:40:28 +00:00
|
|
|
New = ConstantExpr::getGetElementPtrTy(NewTy, OldC->getOperand(0),
|
|
|
|
&Idx[0], Idx.size());
|
2003-11-21 20:23:48 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-11-21 20:23:48 +00:00
|
|
|
assert(New != OldC && "Didn't replace constant??");
|
|
|
|
OldC->uncheckedReplaceAllUsesWith(New);
|
|
|
|
OldC->destroyConstant(); // This constant is now dead, destroy it.
|
2003-10-05 00:17:43 +00:00
|
|
|
}
|
2003-11-21 20:23:48 +00:00
|
|
|
};
|
|
|
|
} // end namespace llvm
|
2003-05-23 20:03:32 +00:00
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2004-08-04 04:48:01 +00:00
|
|
|
static ExprMapKeyType getValType(ConstantExpr *CE) {
|
|
|
|
std::vector<Constant*> Operands;
|
|
|
|
Operands.reserve(CE->getNumOperands());
|
|
|
|
for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i)
|
|
|
|
Operands.push_back(cast<Constant>(CE->getOperand(i)));
|
2006-12-04 05:19:50 +00:00
|
|
|
return ExprMapKeyType(CE->getOpcode(), Operands,
|
|
|
|
CE->isCompare() ? CE->getPredicate() : 0);
|
2004-08-04 04:48:01 +00:00
|
|
|
}
|
|
|
|
|
2006-09-28 00:35:06 +00:00
|
|
|
static ManagedStatic<ValueMap<ExprMapKeyType, Type,
|
|
|
|
ConstantExpr> > ExprConstants;
|
2002-07-15 18:19:33 +00:00
|
|
|
|
2006-11-27 01:05:10 +00:00
|
|
|
/// This is a utility function to handle folding of casts and lookup of the
|
2008-03-30 19:38:55 +00:00
|
|
|
/// cast in the ExprConstants map. It is used by the various get* methods below.
|
2006-11-27 01:05:10 +00:00
|
|
|
static inline Constant *getFoldedCast(
|
|
|
|
Instruction::CastOps opc, Constant *C, const Type *Ty) {
|
2003-10-07 22:19:19 +00:00
|
|
|
assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
|
2006-11-27 01:05:10 +00:00
|
|
|
// Fold a few common cases
|
|
|
|
if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
|
|
|
|
return FC;
|
2003-04-17 19:24:48 +00:00
|
|
|
|
2002-07-15 18:19:33 +00:00
|
|
|
// Look up the constant in the table first to ensure uniqueness
|
2003-05-13 21:37:02 +00:00
|
|
|
std::vector<Constant*> argVec(1, C);
|
2006-12-04 05:19:50 +00:00
|
|
|
ExprMapKeyType Key(opc, argVec);
|
2006-09-28 00:35:06 +00:00
|
|
|
return ExprConstants->getOrCreate(Ty, Key);
|
2002-07-14 23:13:17 +00:00
|
|
|
}
|
2006-12-05 19:14:13 +00:00
|
|
|
|
2006-11-27 01:05:10 +00:00
|
|
|
Constant *ConstantExpr::getCast(unsigned oc, Constant *C, const Type *Ty) {
|
|
|
|
Instruction::CastOps opc = Instruction::CastOps(oc);
|
|
|
|
assert(Instruction::isCast(opc) && "opcode out of range");
|
|
|
|
assert(C && Ty && "Null arguments to getCast");
|
|
|
|
assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
|
|
|
|
|
|
|
|
switch (opc) {
|
|
|
|
default:
|
|
|
|
assert(0 && "Invalid cast opcode");
|
|
|
|
break;
|
|
|
|
case Instruction::Trunc: return getTrunc(C, Ty);
|
2006-12-12 23:36:14 +00:00
|
|
|
case Instruction::ZExt: return getZExt(C, Ty);
|
|
|
|
case Instruction::SExt: return getSExt(C, Ty);
|
2006-11-27 01:05:10 +00:00
|
|
|
case Instruction::FPTrunc: return getFPTrunc(C, Ty);
|
|
|
|
case Instruction::FPExt: return getFPExtend(C, Ty);
|
|
|
|
case Instruction::UIToFP: return getUIToFP(C, Ty);
|
|
|
|
case Instruction::SIToFP: return getSIToFP(C, Ty);
|
|
|
|
case Instruction::FPToUI: return getFPToUI(C, Ty);
|
|
|
|
case Instruction::FPToSI: return getFPToSI(C, Ty);
|
|
|
|
case Instruction::PtrToInt: return getPtrToInt(C, Ty);
|
|
|
|
case Instruction::IntToPtr: return getIntToPtr(C, Ty);
|
|
|
|
case Instruction::BitCast: return getBitCast(C, Ty);
|
2005-01-01 15:59:57 +00:00
|
|
|
}
|
2006-11-27 01:05:10 +00:00
|
|
|
return 0;
|
2006-12-05 19:14:13 +00:00
|
|
|
}
|
|
|
|
|
2006-12-04 20:17:56 +00:00
|
|
|
Constant *ConstantExpr::getZExtOrBitCast(Constant *C, const Type *Ty) {
|
|
|
|
if (C->getType()->getPrimitiveSizeInBits() == Ty->getPrimitiveSizeInBits())
|
|
|
|
return getCast(Instruction::BitCast, C, Ty);
|
|
|
|
return getCast(Instruction::ZExt, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getSExtOrBitCast(Constant *C, const Type *Ty) {
|
|
|
|
if (C->getType()->getPrimitiveSizeInBits() == Ty->getPrimitiveSizeInBits())
|
|
|
|
return getCast(Instruction::BitCast, C, Ty);
|
|
|
|
return getCast(Instruction::SExt, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getTruncOrBitCast(Constant *C, const Type *Ty) {
|
|
|
|
if (C->getType()->getPrimitiveSizeInBits() == Ty->getPrimitiveSizeInBits())
|
|
|
|
return getCast(Instruction::BitCast, C, Ty);
|
|
|
|
return getCast(Instruction::Trunc, C, Ty);
|
|
|
|
}
|
|
|
|
|
2006-12-05 03:25:26 +00:00
|
|
|
Constant *ConstantExpr::getPointerCast(Constant *S, const Type *Ty) {
|
|
|
|
assert(isa<PointerType>(S->getType()) && "Invalid cast");
|
2007-01-15 02:27:26 +00:00
|
|
|
assert((Ty->isInteger() || isa<PointerType>(Ty)) && "Invalid cast");
|
2006-12-05 03:25:26 +00:00
|
|
|
|
2007-01-15 02:27:26 +00:00
|
|
|
if (Ty->isInteger())
|
2006-12-05 03:25:26 +00:00
|
|
|
return getCast(Instruction::PtrToInt, S, Ty);
|
|
|
|
return getCast(Instruction::BitCast, S, Ty);
|
|
|
|
}
|
|
|
|
|
2006-12-12 00:51:07 +00:00
|
|
|
Constant *ConstantExpr::getIntegerCast(Constant *C, const Type *Ty,
|
|
|
|
bool isSigned) {
|
2007-01-15 02:27:26 +00:00
|
|
|
assert(C->getType()->isInteger() && Ty->isInteger() && "Invalid cast");
|
2006-12-12 00:51:07 +00:00
|
|
|
unsigned SrcBits = C->getType()->getPrimitiveSizeInBits();
|
|
|
|
unsigned DstBits = Ty->getPrimitiveSizeInBits();
|
|
|
|
Instruction::CastOps opcode =
|
|
|
|
(SrcBits == DstBits ? Instruction::BitCast :
|
|
|
|
(SrcBits > DstBits ? Instruction::Trunc :
|
|
|
|
(isSigned ? Instruction::SExt : Instruction::ZExt)));
|
|
|
|
return getCast(opcode, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getFPCast(Constant *C, const Type *Ty) {
|
|
|
|
assert(C->getType()->isFloatingPoint() && Ty->isFloatingPoint() &&
|
|
|
|
"Invalid cast");
|
|
|
|
unsigned SrcBits = C->getType()->getPrimitiveSizeInBits();
|
|
|
|
unsigned DstBits = Ty->getPrimitiveSizeInBits();
|
2006-12-12 05:38:50 +00:00
|
|
|
if (SrcBits == DstBits)
|
|
|
|
return C; // Avoid a useless cast
|
2006-12-12 00:51:07 +00:00
|
|
|
Instruction::CastOps opcode =
|
2006-12-12 05:38:50 +00:00
|
|
|
(SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);
|
2006-12-12 00:51:07 +00:00
|
|
|
return getCast(opcode, C, Ty);
|
|
|
|
}
|
|
|
|
|
2006-11-27 01:05:10 +00:00
|
|
|
Constant *ConstantExpr::getTrunc(Constant *C, const Type *Ty) {
|
2007-01-15 02:27:26 +00:00
|
|
|
assert(C->getType()->isInteger() && "Trunc operand must be integer");
|
|
|
|
assert(Ty->isInteger() && "Trunc produces only integral");
|
2006-11-27 01:05:10 +00:00
|
|
|
assert(C->getType()->getPrimitiveSizeInBits() > Ty->getPrimitiveSizeInBits()&&
|
|
|
|
"SrcTy must be larger than DestTy for Trunc!");
|
|
|
|
|
|
|
|
return getFoldedCast(Instruction::Trunc, C, Ty);
|
|
|
|
}
|
|
|
|
|
2006-12-12 23:36:14 +00:00
|
|
|
Constant *ConstantExpr::getSExt(Constant *C, const Type *Ty) {
|
2007-01-15 02:27:26 +00:00
|
|
|
assert(C->getType()->isInteger() && "SEXt operand must be integral");
|
|
|
|
assert(Ty->isInteger() && "SExt produces only integer");
|
2006-11-27 01:05:10 +00:00
|
|
|
assert(C->getType()->getPrimitiveSizeInBits() < Ty->getPrimitiveSizeInBits()&&
|
|
|
|
"SrcTy must be smaller than DestTy for SExt!");
|
|
|
|
|
|
|
|
return getFoldedCast(Instruction::SExt, C, Ty);
|
2004-04-04 23:20:30 +00:00
|
|
|
}
|
|
|
|
|
2006-12-12 23:36:14 +00:00
|
|
|
Constant *ConstantExpr::getZExt(Constant *C, const Type *Ty) {
|
2007-01-15 02:27:26 +00:00
|
|
|
assert(C->getType()->isInteger() && "ZEXt operand must be integral");
|
|
|
|
assert(Ty->isInteger() && "ZExt produces only integer");
|
2006-11-27 01:05:10 +00:00
|
|
|
assert(C->getType()->getPrimitiveSizeInBits() < Ty->getPrimitiveSizeInBits()&&
|
|
|
|
"SrcTy must be smaller than DestTy for ZExt!");
|
|
|
|
|
|
|
|
return getFoldedCast(Instruction::ZExt, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getFPTrunc(Constant *C, const Type *Ty) {
|
|
|
|
assert(C->getType()->isFloatingPoint() && Ty->isFloatingPoint() &&
|
|
|
|
C->getType()->getPrimitiveSizeInBits() > Ty->getPrimitiveSizeInBits()&&
|
|
|
|
"This is an illegal floating point truncation!");
|
|
|
|
return getFoldedCast(Instruction::FPTrunc, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getFPExtend(Constant *C, const Type *Ty) {
|
|
|
|
assert(C->getType()->isFloatingPoint() && Ty->isFloatingPoint() &&
|
|
|
|
C->getType()->getPrimitiveSizeInBits() < Ty->getPrimitiveSizeInBits()&&
|
|
|
|
"This is an illegal floating point extension!");
|
|
|
|
return getFoldedCast(Instruction::FPExt, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getUIToFP(Constant *C, const Type *Ty) {
|
2007-11-17 03:58:34 +00:00
|
|
|
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
|
|
|
|
bool toVec = Ty->getTypeID() == Type::VectorTyID;
|
|
|
|
assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
|
|
|
|
assert(C->getType()->isIntOrIntVector() && Ty->isFPOrFPVector() &&
|
|
|
|
"This is an illegal uint to floating point cast!");
|
2006-11-27 01:05:10 +00:00
|
|
|
return getFoldedCast(Instruction::UIToFP, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getSIToFP(Constant *C, const Type *Ty) {
|
2007-11-17 03:58:34 +00:00
|
|
|
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
|
|
|
|
bool toVec = Ty->getTypeID() == Type::VectorTyID;
|
|
|
|
assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
|
|
|
|
assert(C->getType()->isIntOrIntVector() && Ty->isFPOrFPVector() &&
|
2006-11-27 01:05:10 +00:00
|
|
|
"This is an illegal sint to floating point cast!");
|
|
|
|
return getFoldedCast(Instruction::SIToFP, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getFPToUI(Constant *C, const Type *Ty) {
|
2007-11-17 03:58:34 +00:00
|
|
|
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
|
|
|
|
bool toVec = Ty->getTypeID() == Type::VectorTyID;
|
|
|
|
assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
|
|
|
|
assert(C->getType()->isFPOrFPVector() && Ty->isIntOrIntVector() &&
|
|
|
|
"This is an illegal floating point to uint cast!");
|
2006-11-27 01:05:10 +00:00
|
|
|
return getFoldedCast(Instruction::FPToUI, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getFPToSI(Constant *C, const Type *Ty) {
|
2007-11-17 03:58:34 +00:00
|
|
|
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
|
|
|
|
bool toVec = Ty->getTypeID() == Type::VectorTyID;
|
|
|
|
assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
|
|
|
|
assert(C->getType()->isFPOrFPVector() && Ty->isIntOrIntVector() &&
|
|
|
|
"This is an illegal floating point to sint cast!");
|
2006-11-27 01:05:10 +00:00
|
|
|
return getFoldedCast(Instruction::FPToSI, C, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getPtrToInt(Constant *C, const Type *DstTy) {
|
|
|
|
assert(isa<PointerType>(C->getType()) && "PtrToInt source must be pointer");
|
2007-01-15 02:27:26 +00:00
|
|
|
assert(DstTy->isInteger() && "PtrToInt destination must be integral");
|
2006-11-27 01:05:10 +00:00
|
|
|
return getFoldedCast(Instruction::PtrToInt, C, DstTy);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getIntToPtr(Constant *C, const Type *DstTy) {
|
2007-01-15 02:27:26 +00:00
|
|
|
assert(C->getType()->isInteger() && "IntToPtr source must be integral");
|
2006-11-27 01:05:10 +00:00
|
|
|
assert(isa<PointerType>(DstTy) && "IntToPtr destination must be a pointer");
|
|
|
|
return getFoldedCast(Instruction::IntToPtr, C, DstTy);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getBitCast(Constant *C, const Type *DstTy) {
|
|
|
|
// BitCast implies a no-op cast of type only. No bits change. However, you
|
|
|
|
// can't cast pointers to anything but pointers.
|
|
|
|
const Type *SrcTy = C->getType();
|
|
|
|
assert((isa<PointerType>(SrcTy) == isa<PointerType>(DstTy)) &&
|
2006-12-04 20:17:56 +00:00
|
|
|
"BitCast cannot cast pointer to non-pointer and vice versa");
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Now we know we're not dealing with mismatched pointer casts (ptr->nonptr
|
|
|
|
// or nonptr->ptr). For all the other types, the cast is okay if source and
|
|
|
|
// destination bit widths are identical.
|
|
|
|
unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
|
|
|
|
unsigned DstBitSize = DstTy->getPrimitiveSizeInBits();
|
2006-12-04 20:17:56 +00:00
|
|
|
assert(SrcBitSize == DstBitSize && "BitCast requies types of same width");
|
2006-11-27 01:05:10 +00:00
|
|
|
return getFoldedCast(Instruction::BitCast, C, DstTy);
|
2004-04-04 23:20:30 +00:00
|
|
|
}
|
|
|
|
|
2004-10-24 01:41:10 +00:00
|
|
|
Constant *ConstantExpr::getSizeOf(const Type *Ty) {
|
2007-10-06 14:29:36 +00:00
|
|
|
// sizeof is implemented as: (i64) gep (Ty*)null, 1
|
2007-02-19 20:01:23 +00:00
|
|
|
Constant *GEPIdx = ConstantInt::get(Type::Int32Ty, 1);
|
|
|
|
Constant *GEP =
|
2007-12-17 01:12:55 +00:00
|
|
|
getGetElementPtr(getNullValue(PointerType::getUnqual(Ty)), &GEPIdx, 1);
|
2007-02-19 20:01:23 +00:00
|
|
|
return getCast(Instruction::PtrToInt, GEP, Type::Int64Ty);
|
2005-03-19 11:40:31 +00:00
|
|
|
}
|
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode,
|
2006-12-04 21:35:24 +00:00
|
|
|
Constant *C1, Constant *C2) {
|
2003-05-21 17:49:25 +00:00
|
|
|
// Check the operands for consistency first
|
2006-11-02 01:53:59 +00:00
|
|
|
assert(Opcode >= Instruction::BinaryOpsBegin &&
|
|
|
|
Opcode < Instruction::BinaryOpsEnd &&
|
2003-05-21 17:49:25 +00:00
|
|
|
"Invalid opcode in binary constant expression");
|
|
|
|
assert(C1->getType() == C2->getType() &&
|
|
|
|
"Operand types in binary constant expression should match");
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2007-01-11 18:21:29 +00:00
|
|
|
if (ReqTy == C1->getType() || ReqTy == Type::Int1Ty)
|
2003-10-05 00:17:43 +00:00
|
|
|
if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
|
|
|
|
return FC; // Fold a few common cases...
|
2003-04-17 19:24:48 +00:00
|
|
|
|
2003-05-13 21:37:02 +00:00
|
|
|
std::vector<Constant*> argVec(1, C1); argVec.push_back(C2);
|
2006-12-04 21:35:24 +00:00
|
|
|
ExprMapKeyType Key(Opcode, argVec);
|
2006-09-28 00:35:06 +00:00
|
|
|
return ExprConstants->getOrCreate(ReqTy, Key);
|
2003-05-21 17:49:25 +00:00
|
|
|
}
|
|
|
|
|
2006-12-23 06:05:41 +00:00
|
|
|
Constant *ConstantExpr::getCompareTy(unsigned short predicate,
|
2006-12-04 21:35:24 +00:00
|
|
|
Constant *C1, Constant *C2) {
|
2006-12-23 06:05:41 +00:00
|
|
|
switch (predicate) {
|
|
|
|
default: assert(0 && "Invalid CmpInst predicate");
|
|
|
|
case FCmpInst::FCMP_FALSE: case FCmpInst::FCMP_OEQ: case FCmpInst::FCMP_OGT:
|
|
|
|
case FCmpInst::FCMP_OGE: case FCmpInst::FCMP_OLT: case FCmpInst::FCMP_OLE:
|
|
|
|
case FCmpInst::FCMP_ONE: case FCmpInst::FCMP_ORD: case FCmpInst::FCMP_UNO:
|
|
|
|
case FCmpInst::FCMP_UEQ: case FCmpInst::FCMP_UGT: case FCmpInst::FCMP_UGE:
|
|
|
|
case FCmpInst::FCMP_ULT: case FCmpInst::FCMP_ULE: case FCmpInst::FCMP_UNE:
|
|
|
|
case FCmpInst::FCMP_TRUE:
|
|
|
|
return getFCmp(predicate, C1, C2);
|
|
|
|
case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_UGT:
|
|
|
|
case ICmpInst::ICMP_UGE: case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_ULE:
|
|
|
|
case ICmpInst::ICMP_SGT: case ICmpInst::ICMP_SGE: case ICmpInst::ICMP_SLT:
|
|
|
|
case ICmpInst::ICMP_SLE:
|
|
|
|
return getICmp(predicate, C1, C2);
|
|
|
|
}
|
2006-12-04 21:35:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2) {
|
2004-08-17 17:28:46 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
switch (Opcode) {
|
2006-11-02 01:53:59 +00:00
|
|
|
case Instruction::Add:
|
|
|
|
case Instruction::Sub:
|
2006-10-26 06:15:43 +00:00
|
|
|
case Instruction::Mul:
|
2004-08-17 17:28:46 +00:00
|
|
|
assert(C1->getType() == C2->getType() && "Op types should be identical!");
|
2007-01-15 02:27:26 +00:00
|
|
|
assert((C1->getType()->isInteger() || C1->getType()->isFloatingPoint() ||
|
2007-02-15 02:26:10 +00:00
|
|
|
isa<VectorType>(C1->getType())) &&
|
2004-08-17 17:28:46 +00:00
|
|
|
"Tried to create an arithmetic operation on a non-arithmetic type!");
|
|
|
|
break;
|
2006-10-26 06:15:43 +00:00
|
|
|
case Instruction::UDiv:
|
|
|
|
case Instruction::SDiv:
|
|
|
|
assert(C1->getType() == C2->getType() && "Op types should be identical!");
|
2007-02-15 02:26:10 +00:00
|
|
|
assert((C1->getType()->isInteger() || (isa<VectorType>(C1->getType()) &&
|
|
|
|
cast<VectorType>(C1->getType())->getElementType()->isInteger())) &&
|
2006-10-26 06:15:43 +00:00
|
|
|
"Tried to create an arithmetic operation on a non-arithmetic type!");
|
|
|
|
break;
|
|
|
|
case Instruction::FDiv:
|
|
|
|
assert(C1->getType() == C2->getType() && "Op types should be identical!");
|
2007-02-15 02:26:10 +00:00
|
|
|
assert((C1->getType()->isFloatingPoint() || (isa<VectorType>(C1->getType())
|
|
|
|
&& cast<VectorType>(C1->getType())->getElementType()->isFloatingPoint()))
|
2006-10-26 06:15:43 +00:00
|
|
|
&& "Tried to create an arithmetic operation on a non-arithmetic type!");
|
|
|
|
break;
|
2006-11-02 01:53:59 +00:00
|
|
|
case Instruction::URem:
|
|
|
|
case Instruction::SRem:
|
|
|
|
assert(C1->getType() == C2->getType() && "Op types should be identical!");
|
2007-02-15 02:26:10 +00:00
|
|
|
assert((C1->getType()->isInteger() || (isa<VectorType>(C1->getType()) &&
|
|
|
|
cast<VectorType>(C1->getType())->getElementType()->isInteger())) &&
|
2006-11-02 01:53:59 +00:00
|
|
|
"Tried to create an arithmetic operation on a non-arithmetic type!");
|
|
|
|
break;
|
|
|
|
case Instruction::FRem:
|
|
|
|
assert(C1->getType() == C2->getType() && "Op types should be identical!");
|
2007-02-15 02:26:10 +00:00
|
|
|
assert((C1->getType()->isFloatingPoint() || (isa<VectorType>(C1->getType())
|
|
|
|
&& cast<VectorType>(C1->getType())->getElementType()->isFloatingPoint()))
|
2006-11-02 01:53:59 +00:00
|
|
|
&& "Tried to create an arithmetic operation on a non-arithmetic type!");
|
|
|
|
break;
|
2004-08-17 17:28:46 +00:00
|
|
|
case Instruction::And:
|
|
|
|
case Instruction::Or:
|
|
|
|
case Instruction::Xor:
|
|
|
|
assert(C1->getType() == C2->getType() && "Op types should be identical!");
|
2007-02-15 02:26:10 +00:00
|
|
|
assert((C1->getType()->isInteger() || isa<VectorType>(C1->getType())) &&
|
2005-01-27 06:46:38 +00:00
|
|
|
"Tried to create a logical operation on a non-integral type!");
|
2004-08-17 17:28:46 +00:00
|
|
|
break;
|
|
|
|
case Instruction::Shl:
|
2006-11-08 06:47:33 +00:00
|
|
|
case Instruction::LShr:
|
|
|
|
case Instruction::AShr:
|
2007-02-02 02:16:23 +00:00
|
|
|
assert(C1->getType() == C2->getType() && "Op types should be identical!");
|
2007-01-15 02:27:26 +00:00
|
|
|
assert(C1->getType()->isInteger() &&
|
2004-08-17 17:28:46 +00:00
|
|
|
"Tried to create a shift operation on a non-integer type!");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-12-04 21:35:24 +00:00
|
|
|
return getTy(C1->getType(), Opcode, C1, C2);
|
|
|
|
}
|
|
|
|
|
2006-12-23 06:05:41 +00:00
|
|
|
Constant *ConstantExpr::getCompare(unsigned short pred,
|
2006-12-04 21:35:24 +00:00
|
|
|
Constant *C1, Constant *C2) {
|
|
|
|
assert(C1->getType() == C2->getType() && "Op types should be identical!");
|
2006-12-23 06:05:41 +00:00
|
|
|
return getCompareTy(pred, C1, C2);
|
2004-08-04 18:50:09 +00:00
|
|
|
}
|
|
|
|
|
2004-03-12 05:54:04 +00:00
|
|
|
Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C,
|
|
|
|
Constant *V1, Constant *V2) {
|
2007-01-26 07:37:34 +00:00
|
|
|
assert(C->getType() == Type::Int1Ty && "Select condition must be i1!");
|
2004-03-12 05:54:04 +00:00
|
|
|
assert(V1->getType() == V2->getType() && "Select value types must match!");
|
|
|
|
assert(V1->getType()->isFirstClassType() && "Cannot select aggregate type!");
|
|
|
|
|
|
|
|
if (ReqTy == V1->getType())
|
|
|
|
if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2))
|
|
|
|
return SC; // Fold common cases
|
|
|
|
|
|
|
|
std::vector<Constant*> argVec(3, C);
|
|
|
|
argVec[1] = V1;
|
|
|
|
argVec[2] = V2;
|
2006-12-04 05:19:50 +00:00
|
|
|
ExprMapKeyType Key(Instruction::Select, argVec);
|
2006-09-28 00:35:06 +00:00
|
|
|
return ExprConstants->getOrCreate(ReqTy, Key);
|
2004-03-12 05:54:04 +00:00
|
|
|
}
|
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C,
|
2007-01-31 04:40:28 +00:00
|
|
|
Value* const *Idxs,
|
|
|
|
unsigned NumIdx) {
|
2007-09-04 15:46:09 +00:00
|
|
|
assert(GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true) &&
|
2004-02-16 20:46:13 +00:00
|
|
|
"GEP indices invalid!");
|
|
|
|
|
2007-01-31 04:40:28 +00:00
|
|
|
if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs, NumIdx))
|
2003-04-17 19:24:48 +00:00
|
|
|
return FC; // Fold a few common cases...
|
2004-02-16 20:46:13 +00:00
|
|
|
|
2003-10-05 00:17:43 +00:00
|
|
|
assert(isa<PointerType>(C->getType()) &&
|
2003-05-23 20:03:32 +00:00
|
|
|
"Non-pointer type for constant GetElementPtr expression");
|
2002-07-15 18:19:33 +00:00
|
|
|
// Look up the constant in the table first to ensure uniqueness
|
2004-10-11 22:52:25 +00:00
|
|
|
std::vector<Constant*> ArgVec;
|
2007-01-31 04:40:28 +00:00
|
|
|
ArgVec.reserve(NumIdx+1);
|
2004-10-11 22:52:25 +00:00
|
|
|
ArgVec.push_back(C);
|
2007-01-31 04:40:28 +00:00
|
|
|
for (unsigned i = 0; i != NumIdx; ++i)
|
|
|
|
ArgVec.push_back(cast<Constant>(Idxs[i]));
|
|
|
|
const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec);
|
2006-09-28 00:35:06 +00:00
|
|
|
return ExprConstants->getOrCreate(ReqTy, Key);
|
2003-10-05 00:17:43 +00:00
|
|
|
}
|
|
|
|
|
2007-01-31 04:40:28 +00:00
|
|
|
Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs,
|
|
|
|
unsigned NumIdx) {
|
2003-10-05 00:17:43 +00:00
|
|
|
// Get the result type of the getelementptr!
|
2007-01-31 04:40:28 +00:00
|
|
|
const Type *Ty =
|
2007-09-04 15:46:09 +00:00
|
|
|
GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true);
|
2003-10-05 00:17:43 +00:00
|
|
|
assert(Ty && "GEP indices invalid!");
|
2007-12-11 08:59:05 +00:00
|
|
|
unsigned As = cast<PointerType>(C->getType())->getAddressSpace();
|
|
|
|
return getGetElementPtrTy(PointerType::get(Ty, As), C, Idxs, NumIdx);
|
2004-10-11 22:52:25 +00:00
|
|
|
}
|
|
|
|
|
2007-01-31 04:40:28 +00:00
|
|
|
Constant *ConstantExpr::getGetElementPtr(Constant *C, Constant* const *Idxs,
|
|
|
|
unsigned NumIdx) {
|
|
|
|
return getGetElementPtr(C, (Value* const *)Idxs, NumIdx);
|
2002-07-15 18:19:33 +00:00
|
|
|
}
|
|
|
|
|
2007-01-31 04:40:28 +00:00
|
|
|
|
2006-12-04 05:19:50 +00:00
|
|
|
Constant *
|
|
|
|
ConstantExpr::getICmp(unsigned short pred, Constant* LHS, Constant* RHS) {
|
|
|
|
assert(LHS->getType() == RHS->getType());
|
|
|
|
assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE &&
|
|
|
|
pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate");
|
|
|
|
|
2006-12-23 06:05:41 +00:00
|
|
|
if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
|
2006-12-04 05:19:50 +00:00
|
|
|
return FC; // Fold a few common cases...
|
|
|
|
|
|
|
|
// Look up the constant in the table first to ensure uniqueness
|
|
|
|
std::vector<Constant*> ArgVec;
|
|
|
|
ArgVec.push_back(LHS);
|
|
|
|
ArgVec.push_back(RHS);
|
2006-12-24 18:42:29 +00:00
|
|
|
// Get the key type with both the opcode and predicate
|
2006-12-04 05:19:50 +00:00
|
|
|
const ExprMapKeyType Key(Instruction::ICmp, ArgVec, pred);
|
2007-01-11 18:21:29 +00:00
|
|
|
return ExprConstants->getOrCreate(Type::Int1Ty, Key);
|
2006-12-04 05:19:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Constant *
|
|
|
|
ConstantExpr::getFCmp(unsigned short pred, Constant* LHS, Constant* RHS) {
|
|
|
|
assert(LHS->getType() == RHS->getType());
|
|
|
|
assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate");
|
|
|
|
|
2006-12-23 06:05:41 +00:00
|
|
|
if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
|
2006-12-04 05:19:50 +00:00
|
|
|
return FC; // Fold a few common cases...
|
|
|
|
|
|
|
|
// Look up the constant in the table first to ensure uniqueness
|
|
|
|
std::vector<Constant*> ArgVec;
|
|
|
|
ArgVec.push_back(LHS);
|
|
|
|
ArgVec.push_back(RHS);
|
2006-12-24 18:42:29 +00:00
|
|
|
// Get the key type with both the opcode and predicate
|
2006-12-04 05:19:50 +00:00
|
|
|
const ExprMapKeyType Key(Instruction::FCmp, ArgVec, pred);
|
2007-01-11 18:21:29 +00:00
|
|
|
return ExprConstants->getOrCreate(Type::Int1Ty, Key);
|
2006-12-04 05:19:50 +00:00
|
|
|
}
|
|
|
|
|
2006-01-10 19:05:34 +00:00
|
|
|
Constant *ConstantExpr::getExtractElementTy(const Type *ReqTy, Constant *Val,
|
|
|
|
Constant *Idx) {
|
2006-01-10 20:03:46 +00:00
|
|
|
if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx))
|
|
|
|
return FC; // Fold a few common cases...
|
2006-01-10 19:05:34 +00:00
|
|
|
// Look up the constant in the table first to ensure uniqueness
|
|
|
|
std::vector<Constant*> ArgVec(1, Val);
|
|
|
|
ArgVec.push_back(Idx);
|
2006-12-04 05:19:50 +00:00
|
|
|
const ExprMapKeyType Key(Instruction::ExtractElement,ArgVec);
|
2006-09-28 00:35:06 +00:00
|
|
|
return ExprConstants->getOrCreate(ReqTy, Key);
|
2006-01-10 19:05:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) {
|
2007-02-15 02:26:10 +00:00
|
|
|
assert(isa<VectorType>(Val->getType()) &&
|
2007-02-15 03:39:18 +00:00
|
|
|
"Tried to create extractelement operation on non-vector type!");
|
2006-12-31 05:26:44 +00:00
|
|
|
assert(Idx->getType() == Type::Int32Ty &&
|
2007-01-26 07:37:34 +00:00
|
|
|
"Extractelement index must be i32 type!");
|
2007-02-15 02:26:10 +00:00
|
|
|
return getExtractElementTy(cast<VectorType>(Val->getType())->getElementType(),
|
2006-01-10 19:05:34 +00:00
|
|
|
Val, Idx);
|
|
|
|
}
|
2003-10-05 00:17:43 +00:00
|
|
|
|
2006-01-17 20:07:22 +00:00
|
|
|
Constant *ConstantExpr::getInsertElementTy(const Type *ReqTy, Constant *Val,
|
|
|
|
Constant *Elt, Constant *Idx) {
|
|
|
|
if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx))
|
|
|
|
return FC; // Fold a few common cases...
|
|
|
|
// Look up the constant in the table first to ensure uniqueness
|
|
|
|
std::vector<Constant*> ArgVec(1, Val);
|
|
|
|
ArgVec.push_back(Elt);
|
|
|
|
ArgVec.push_back(Idx);
|
2006-12-04 05:19:50 +00:00
|
|
|
const ExprMapKeyType Key(Instruction::InsertElement,ArgVec);
|
2006-09-28 00:35:06 +00:00
|
|
|
return ExprConstants->getOrCreate(ReqTy, Key);
|
2006-01-17 20:07:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt,
|
|
|
|
Constant *Idx) {
|
2007-02-15 02:26:10 +00:00
|
|
|
assert(isa<VectorType>(Val->getType()) &&
|
2007-02-15 03:39:18 +00:00
|
|
|
"Tried to create insertelement operation on non-vector type!");
|
2007-02-15 02:26:10 +00:00
|
|
|
assert(Elt->getType() == cast<VectorType>(Val->getType())->getElementType()
|
2006-01-17 20:07:22 +00:00
|
|
|
&& "Insertelement types must match!");
|
2006-12-31 05:26:44 +00:00
|
|
|
assert(Idx->getType() == Type::Int32Ty &&
|
2007-01-26 07:37:34 +00:00
|
|
|
"Insertelement index must be i32 type!");
|
2007-02-15 02:26:10 +00:00
|
|
|
return getInsertElementTy(cast<VectorType>(Val->getType())->getElementType(),
|
2006-01-17 20:07:22 +00:00
|
|
|
Val, Elt, Idx);
|
|
|
|
}
|
|
|
|
|
2006-04-08 01:18:18 +00:00
|
|
|
Constant *ConstantExpr::getShuffleVectorTy(const Type *ReqTy, Constant *V1,
|
|
|
|
Constant *V2, Constant *Mask) {
|
|
|
|
if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask))
|
|
|
|
return FC; // Fold a few common cases...
|
|
|
|
// Look up the constant in the table first to ensure uniqueness
|
|
|
|
std::vector<Constant*> ArgVec(1, V1);
|
|
|
|
ArgVec.push_back(V2);
|
|
|
|
ArgVec.push_back(Mask);
|
2006-12-04 05:19:50 +00:00
|
|
|
const ExprMapKeyType Key(Instruction::ShuffleVector,ArgVec);
|
2006-09-28 00:35:06 +00:00
|
|
|
return ExprConstants->getOrCreate(ReqTy, Key);
|
2006-04-08 01:18:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Constant *ConstantExpr::getShuffleVector(Constant *V1, Constant *V2,
|
|
|
|
Constant *Mask) {
|
|
|
|
assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) &&
|
|
|
|
"Invalid shuffle vector constant expr operands!");
|
|
|
|
return getShuffleVectorTy(V1->getType(), V1, V2, Mask);
|
|
|
|
}
|
|
|
|
|
2007-01-21 00:29:26 +00:00
|
|
|
Constant *ConstantExpr::getZeroValueForNegationExpr(const Type *Ty) {
|
2007-02-15 02:26:10 +00:00
|
|
|
if (const VectorType *PTy = dyn_cast<VectorType>(Ty))
|
2007-01-21 02:29:10 +00:00
|
|
|
if (PTy->getElementType()->isFloatingPoint()) {
|
|
|
|
std::vector<Constant*> zeros(PTy->getNumElements(),
|
2007-09-14 22:26:36 +00:00
|
|
|
ConstantFP::getNegativeZero(PTy->getElementType()));
|
2007-02-15 02:26:10 +00:00
|
|
|
return ConstantVector::get(PTy, zeros);
|
2007-01-21 02:29:10 +00:00
|
|
|
}
|
2007-01-21 00:29:26 +00:00
|
|
|
|
2007-09-14 22:26:36 +00:00
|
|
|
if (Ty->isFloatingPoint())
|
|
|
|
return ConstantFP::getNegativeZero(Ty);
|
2007-01-21 00:29:26 +00:00
|
|
|
|
|
|
|
return Constant::getNullValue(Ty);
|
|
|
|
}
|
|
|
|
|
2002-07-15 18:19:33 +00:00
|
|
|
// destroyConstant - Remove the constant from the constant table...
|
|
|
|
//
|
|
|
|
void ConstantExpr::destroyConstant() {
|
2006-09-28 00:35:06 +00:00
|
|
|
ExprConstants->remove(this);
|
2002-07-15 18:19:33 +00:00
|
|
|
destroyConstantImpl();
|
2002-07-14 23:13:17 +00:00
|
|
|
}
|
|
|
|
|
2002-07-30 18:54:25 +00:00
|
|
|
const char *ConstantExpr::getOpcodeName() const {
|
|
|
|
return Instruction::getOpcodeName(getOpcode());
|
2002-07-14 23:13:17 +00:00
|
|
|
}
|
2004-07-17 23:48:33 +00:00
|
|
|
|
2005-10-03 21:58:36 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// replaceUsesOfWithOnConstant implementations
|
|
|
|
|
2007-08-21 00:55:23 +00:00
|
|
|
/// replaceUsesOfWithOnConstant - Update this constant array to change uses of
|
|
|
|
/// 'From' to be uses of 'To'. This must update the uniquing data structures
|
|
|
|
/// etc.
|
|
|
|
///
|
|
|
|
/// Note that we intentionally replace all uses of From with To here. Consider
|
|
|
|
/// a large array that uses 'From' 1000 times. By handling this case all here,
|
|
|
|
/// ConstantArray::replaceUsesOfWithOnConstant is only invoked once, and that
|
|
|
|
/// single invocation handles all 1000 uses. Handling them one at a time would
|
|
|
|
/// work, but would be really slow because it would have to unique each updated
|
|
|
|
/// array instance.
|
2005-10-03 21:58:36 +00:00
|
|
|
void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To,
|
2005-10-04 18:13:04 +00:00
|
|
|
Use *U) {
|
2005-10-03 21:58:36 +00:00
|
|
|
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
|
2005-10-04 01:17:50 +00:00
|
|
|
Constant *ToC = cast<Constant>(To);
|
2005-10-04 18:47:09 +00:00
|
|
|
|
2006-07-17 17:38:29 +00:00
|
|
|
std::pair<ArrayConstantsTy::MapKey, Constant*> Lookup;
|
2005-10-03 22:51:37 +00:00
|
|
|
Lookup.first.first = getType();
|
|
|
|
Lookup.second = this;
|
2005-10-04 18:47:09 +00:00
|
|
|
|
2005-10-03 22:51:37 +00:00
|
|
|
std::vector<Constant*> &Values = Lookup.first.second;
|
|
|
|
Values.reserve(getNumOperands()); // Build replacement array.
|
2005-10-04 18:47:09 +00:00
|
|
|
|
2005-10-04 01:17:50 +00:00
|
|
|
// Fill values with the modified operands of the constant array. Also,
|
|
|
|
// compute whether this turns into an all-zeros array.
|
2005-10-04 18:47:09 +00:00
|
|
|
bool isAllZeros = false;
|
2007-08-21 00:55:23 +00:00
|
|
|
unsigned NumUpdated = 0;
|
2005-10-04 18:47:09 +00:00
|
|
|
if (!ToC->isNullValue()) {
|
2007-08-21 00:55:23 +00:00
|
|
|
for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
|
|
|
|
Constant *Val = cast<Constant>(O->get());
|
|
|
|
if (Val == From) {
|
|
|
|
Val = ToC;
|
|
|
|
++NumUpdated;
|
|
|
|
}
|
|
|
|
Values.push_back(Val);
|
|
|
|
}
|
2005-10-04 18:47:09 +00:00
|
|
|
} else {
|
|
|
|
isAllZeros = true;
|
|
|
|
for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
|
|
|
|
Constant *Val = cast<Constant>(O->get());
|
2007-08-21 00:55:23 +00:00
|
|
|
if (Val == From) {
|
|
|
|
Val = ToC;
|
|
|
|
++NumUpdated;
|
|
|
|
}
|
2005-10-04 18:47:09 +00:00
|
|
|
Values.push_back(Val);
|
|
|
|
if (isAllZeros) isAllZeros = Val->isNullValue();
|
|
|
|
}
|
2005-10-03 21:58:36 +00:00
|
|
|
}
|
|
|
|
|
2005-10-03 22:51:37 +00:00
|
|
|
Constant *Replacement = 0;
|
|
|
|
if (isAllZeros) {
|
|
|
|
Replacement = ConstantAggregateZero::get(getType());
|
|
|
|
} else {
|
|
|
|
// Check to see if we have this array type already.
|
|
|
|
bool Exists;
|
2006-07-17 17:38:29 +00:00
|
|
|
ArrayConstantsTy::MapTy::iterator I =
|
2006-09-28 00:35:06 +00:00
|
|
|
ArrayConstants->InsertOrGetItem(Lookup, Exists);
|
2005-10-03 22:51:37 +00:00
|
|
|
|
|
|
|
if (Exists) {
|
|
|
|
Replacement = I->second;
|
|
|
|
} else {
|
|
|
|
// Okay, the new shape doesn't exist in the system yet. Instead of
|
|
|
|
// creating a new constant array, inserting it, replaceallusesof'ing the
|
|
|
|
// old with the new, then deleting the old... just update the current one
|
|
|
|
// in place!
|
2006-09-28 00:35:06 +00:00
|
|
|
ArrayConstants->MoveConstantToNewSlot(this, I);
|
2005-10-03 22:51:37 +00:00
|
|
|
|
2007-08-21 00:55:23 +00:00
|
|
|
// Update to the new value. Optimize for the case when we have a single
|
|
|
|
// operand that we're changing, but handle bulk updates efficiently.
|
|
|
|
if (NumUpdated == 1) {
|
|
|
|
unsigned OperandToUpdate = U-OperandList;
|
|
|
|
assert(getOperand(OperandToUpdate) == From &&
|
|
|
|
"ReplaceAllUsesWith broken!");
|
|
|
|
setOperand(OperandToUpdate, ToC);
|
|
|
|
} else {
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
|
|
|
|
if (getOperand(i) == From)
|
|
|
|
setOperand(i, ToC);
|
|
|
|
}
|
2005-10-03 22:51:37 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, I do need to replace this with an existing value.
|
2005-10-03 21:58:36 +00:00
|
|
|
assert(Replacement != this && "I didn't contain From!");
|
|
|
|
|
2005-10-04 18:13:04 +00:00
|
|
|
// Everyone using this now uses the replacement.
|
|
|
|
uncheckedReplaceAllUsesWith(Replacement);
|
2005-10-03 21:58:36 +00:00
|
|
|
|
|
|
|
// Delete the old constant!
|
|
|
|
destroyConstant();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To,
|
2005-10-04 18:13:04 +00:00
|
|
|
Use *U) {
|
2005-10-03 21:58:36 +00:00
|
|
|
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
|
2005-10-04 01:17:50 +00:00
|
|
|
Constant *ToC = cast<Constant>(To);
|
|
|
|
|
2005-10-04 18:47:09 +00:00
|
|
|
unsigned OperandToUpdate = U-OperandList;
|
|
|
|
assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!");
|
|
|
|
|
2006-07-17 17:38:29 +00:00
|
|
|
std::pair<StructConstantsTy::MapKey, Constant*> Lookup;
|
2005-10-04 01:17:50 +00:00
|
|
|
Lookup.first.first = getType();
|
|
|
|
Lookup.second = this;
|
|
|
|
std::vector<Constant*> &Values = Lookup.first.second;
|
|
|
|
Values.reserve(getNumOperands()); // Build replacement struct.
|
2005-10-03 21:58:36 +00:00
|
|
|
|
2005-10-04 18:47:09 +00:00
|
|
|
|
2005-10-04 01:17:50 +00:00
|
|
|
// Fill values with the modified operands of the constant struct. Also,
|
|
|
|
// compute whether this turns into an all-zeros struct.
|
2005-10-04 18:47:09 +00:00
|
|
|
bool isAllZeros = false;
|
|
|
|
if (!ToC->isNullValue()) {
|
|
|
|
for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O)
|
|
|
|
Values.push_back(cast<Constant>(O->get()));
|
|
|
|
} else {
|
|
|
|
isAllZeros = true;
|
|
|
|
for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
|
|
|
|
Constant *Val = cast<Constant>(O->get());
|
|
|
|
Values.push_back(Val);
|
|
|
|
if (isAllZeros) isAllZeros = Val->isNullValue();
|
|
|
|
}
|
2005-10-04 01:17:50 +00:00
|
|
|
}
|
2005-10-04 18:47:09 +00:00
|
|
|
Values[OperandToUpdate] = ToC;
|
|
|
|
|
2005-10-04 01:17:50 +00:00
|
|
|
Constant *Replacement = 0;
|
|
|
|
if (isAllZeros) {
|
|
|
|
Replacement = ConstantAggregateZero::get(getType());
|
|
|
|
} else {
|
|
|
|
// Check to see if we have this array type already.
|
|
|
|
bool Exists;
|
2006-07-17 17:38:29 +00:00
|
|
|
StructConstantsTy::MapTy::iterator I =
|
2006-09-28 00:35:06 +00:00
|
|
|
StructConstants->InsertOrGetItem(Lookup, Exists);
|
2005-10-04 01:17:50 +00:00
|
|
|
|
|
|
|
if (Exists) {
|
|
|
|
Replacement = I->second;
|
|
|
|
} else {
|
|
|
|
// Okay, the new shape doesn't exist in the system yet. Instead of
|
|
|
|
// creating a new constant struct, inserting it, replaceallusesof'ing the
|
|
|
|
// old with the new, then deleting the old... just update the current one
|
|
|
|
// in place!
|
2006-09-28 00:35:06 +00:00
|
|
|
StructConstants->MoveConstantToNewSlot(this, I);
|
2005-10-04 01:17:50 +00:00
|
|
|
|
2005-10-04 18:47:09 +00:00
|
|
|
// Update to the new value.
|
|
|
|
setOperand(OperandToUpdate, ToC);
|
2005-10-04 01:17:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2005-10-03 21:58:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(Replacement != this && "I didn't contain From!");
|
|
|
|
|
2005-10-04 18:13:04 +00:00
|
|
|
// Everyone using this now uses the replacement.
|
|
|
|
uncheckedReplaceAllUsesWith(Replacement);
|
2005-10-03 21:58:36 +00:00
|
|
|
|
|
|
|
// Delete the old constant!
|
|
|
|
destroyConstant();
|
|
|
|
}
|
|
|
|
|
2007-02-15 02:26:10 +00:00
|
|
|
void ConstantVector::replaceUsesOfWithOnConstant(Value *From, Value *To,
|
2005-10-04 18:13:04 +00:00
|
|
|
Use *U) {
|
2005-10-03 21:58:36 +00:00
|
|
|
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
|
|
|
|
|
|
|
|
std::vector<Constant*> Values;
|
|
|
|
Values.reserve(getNumOperands()); // Build replacement array...
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
|
|
|
|
Constant *Val = getOperand(i);
|
|
|
|
if (Val == From) Val = cast<Constant>(To);
|
|
|
|
Values.push_back(Val);
|
|
|
|
}
|
|
|
|
|
2007-02-15 02:26:10 +00:00
|
|
|
Constant *Replacement = ConstantVector::get(getType(), Values);
|
2005-10-03 21:58:36 +00:00
|
|
|
assert(Replacement != this && "I didn't contain From!");
|
|
|
|
|
2005-10-04 18:13:04 +00:00
|
|
|
// Everyone using this now uses the replacement.
|
|
|
|
uncheckedReplaceAllUsesWith(Replacement);
|
2005-10-03 21:58:36 +00:00
|
|
|
|
|
|
|
// Delete the old constant!
|
|
|
|
destroyConstant();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV,
|
2005-10-04 18:13:04 +00:00
|
|
|
Use *U) {
|
2005-10-03 21:58:36 +00:00
|
|
|
assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!");
|
|
|
|
Constant *To = cast<Constant>(ToV);
|
|
|
|
|
|
|
|
Constant *Replacement = 0;
|
|
|
|
if (getOpcode() == Instruction::GetElementPtr) {
|
2007-02-19 20:01:23 +00:00
|
|
|
SmallVector<Constant*, 8> Indices;
|
2005-10-03 21:58:36 +00:00
|
|
|
Constant *Pointer = getOperand(0);
|
|
|
|
Indices.reserve(getNumOperands()-1);
|
|
|
|
if (Pointer == From) Pointer = To;
|
|
|
|
|
|
|
|
for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
|
|
|
|
Constant *Val = getOperand(i);
|
|
|
|
if (Val == From) Val = To;
|
|
|
|
Indices.push_back(Val);
|
|
|
|
}
|
2007-02-19 20:01:23 +00:00
|
|
|
Replacement = ConstantExpr::getGetElementPtr(Pointer,
|
|
|
|
&Indices[0], Indices.size());
|
2006-11-27 01:05:10 +00:00
|
|
|
} else if (isCast()) {
|
2005-10-03 21:58:36 +00:00
|
|
|
assert(getOperand(0) == From && "Cast only has one use!");
|
2006-11-27 01:05:10 +00:00
|
|
|
Replacement = ConstantExpr::getCast(getOpcode(), To, getType());
|
2005-10-03 21:58:36 +00:00
|
|
|
} else if (getOpcode() == Instruction::Select) {
|
|
|
|
Constant *C1 = getOperand(0);
|
|
|
|
Constant *C2 = getOperand(1);
|
|
|
|
Constant *C3 = getOperand(2);
|
|
|
|
if (C1 == From) C1 = To;
|
|
|
|
if (C2 == From) C2 = To;
|
|
|
|
if (C3 == From) C3 = To;
|
|
|
|
Replacement = ConstantExpr::getSelect(C1, C2, C3);
|
2006-01-10 19:05:34 +00:00
|
|
|
} else if (getOpcode() == Instruction::ExtractElement) {
|
|
|
|
Constant *C1 = getOperand(0);
|
|
|
|
Constant *C2 = getOperand(1);
|
|
|
|
if (C1 == From) C1 = To;
|
|
|
|
if (C2 == From) C2 = To;
|
|
|
|
Replacement = ConstantExpr::getExtractElement(C1, C2);
|
2006-04-08 05:09:48 +00:00
|
|
|
} else if (getOpcode() == Instruction::InsertElement) {
|
|
|
|
Constant *C1 = getOperand(0);
|
|
|
|
Constant *C2 = getOperand(1);
|
|
|
|
Constant *C3 = getOperand(1);
|
|
|
|
if (C1 == From) C1 = To;
|
|
|
|
if (C2 == From) C2 = To;
|
|
|
|
if (C3 == From) C3 = To;
|
|
|
|
Replacement = ConstantExpr::getInsertElement(C1, C2, C3);
|
|
|
|
} else if (getOpcode() == Instruction::ShuffleVector) {
|
|
|
|
Constant *C1 = getOperand(0);
|
|
|
|
Constant *C2 = getOperand(1);
|
|
|
|
Constant *C3 = getOperand(2);
|
|
|
|
if (C1 == From) C1 = To;
|
|
|
|
if (C2 == From) C2 = To;
|
|
|
|
if (C3 == From) C3 = To;
|
|
|
|
Replacement = ConstantExpr::getShuffleVector(C1, C2, C3);
|
2006-12-04 05:19:50 +00:00
|
|
|
} else if (isCompare()) {
|
|
|
|
Constant *C1 = getOperand(0);
|
|
|
|
Constant *C2 = getOperand(1);
|
|
|
|
if (C1 == From) C1 = To;
|
|
|
|
if (C2 == From) C2 = To;
|
|
|
|
if (getOpcode() == Instruction::ICmp)
|
|
|
|
Replacement = ConstantExpr::getICmp(getPredicate(), C1, C2);
|
|
|
|
else
|
|
|
|
Replacement = ConstantExpr::getFCmp(getPredicate(), C1, C2);
|
2005-10-03 21:58:36 +00:00
|
|
|
} else if (getNumOperands() == 2) {
|
|
|
|
Constant *C1 = getOperand(0);
|
|
|
|
Constant *C2 = getOperand(1);
|
|
|
|
if (C1 == From) C1 = To;
|
|
|
|
if (C2 == From) C2 = To;
|
|
|
|
Replacement = ConstantExpr::get(getOpcode(), C1, C2);
|
|
|
|
} else {
|
|
|
|
assert(0 && "Unknown ConstantExpr type!");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(Replacement != this && "I didn't contain From!");
|
|
|
|
|
2005-10-04 18:13:04 +00:00
|
|
|
// Everyone using this now uses the replacement.
|
|
|
|
uncheckedReplaceAllUsesWith(Replacement);
|
2005-10-03 21:58:36 +00:00
|
|
|
|
|
|
|
// Delete the old constant!
|
|
|
|
destroyConstant();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-03-08 18:11:07 +00:00
|
|
|
/// getStringValue - Turn an LLVM constant pointer that eventually points to a
|
|
|
|
/// global into a string value. Return an empty string if we can't do it.
|
2006-03-10 23:52:03 +00:00
|
|
|
/// Parameter Chop determines if the result is chopped at the first null
|
|
|
|
/// terminator.
|
2006-03-08 18:11:07 +00:00
|
|
|
///
|
2006-03-10 23:52:03 +00:00
|
|
|
std::string Constant::getStringValue(bool Chop, unsigned Offset) {
|
2006-03-08 18:11:07 +00:00
|
|
|
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(this)) {
|
|
|
|
if (GV->hasInitializer() && isa<ConstantArray>(GV->getInitializer())) {
|
|
|
|
ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
|
|
|
|
if (Init->isString()) {
|
|
|
|
std::string Result = Init->getAsString();
|
|
|
|
if (Offset < Result.size()) {
|
|
|
|
// If we are pointing INTO The string, erase the beginning...
|
|
|
|
Result.erase(Result.begin(), Result.begin()+Offset);
|
|
|
|
|
|
|
|
// Take off the null terminator, and any string fragments after it.
|
2006-03-10 23:52:03 +00:00
|
|
|
if (Chop) {
|
|
|
|
std::string::size_type NullPos = Result.find_first_of((char)0);
|
|
|
|
if (NullPos != std::string::npos)
|
|
|
|
Result.erase(Result.begin()+NullPos, Result.end());
|
|
|
|
}
|
2006-03-08 18:11:07 +00:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-11-01 02:30:35 +00:00
|
|
|
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) {
|
|
|
|
if (CE->getOpcode() == Instruction::GetElementPtr) {
|
|
|
|
// Turn a gep into the specified offset.
|
|
|
|
if (CE->getNumOperands() == 3 &&
|
|
|
|
cast<Constant>(CE->getOperand(1))->isNullValue() &&
|
|
|
|
isa<ConstantInt>(CE->getOperand(2))) {
|
|
|
|
Offset += cast<ConstantInt>(CE->getOperand(2))->getZExtValue();
|
|
|
|
return CE->getOperand(0)->getStringValue(Chop, Offset);
|
2006-03-08 18:11:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|