2003-09-30 18:37:50 +00:00
|
|
|
//===-- llvm/Constant.h - Constant class definition -------------*- C++ -*-===//
|
2005-04-21 20:19:05 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 19:59:42 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 20:19:05 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2002-04-28 19:55:58 +00:00
|
|
|
//
|
|
|
|
// This file contains the declaration of the Constant class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLVM_CONSTANT_H
|
|
|
|
#define LLVM_CONSTANT_H
|
|
|
|
|
|
|
|
#include "llvm/User.h"
|
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
namespace llvm {
|
|
|
|
|
2006-06-05 16:29:06 +00:00
|
|
|
/// This is an important base class in LLVM. It provides the common facilities
|
|
|
|
/// of all constant values in an LLVM program. A constant is a value that is
|
|
|
|
/// immutable at runtime. Functions are constants because their address is
|
|
|
|
/// immutable. Same with global variables.
|
|
|
|
///
|
|
|
|
/// All constants share the capabilities provided in this class. All constants
|
|
|
|
/// can have a null value. They can have an operand list. Constants can be
|
|
|
|
/// simple (integer and floating point values), complex (arrays and structures),
|
|
|
|
/// or expression based (computations yielding a constant value composed of
|
|
|
|
/// only certain operators and other constant values).
|
|
|
|
///
|
|
|
|
/// Note that Constants are immutable (once created they never change)
|
|
|
|
/// and are fully shared by structural equivalence. This means that two
|
|
|
|
/// structurally equivalent constants will always have the same address.
|
|
|
|
/// Constant's are created on demand as needed and never deleted: thus clients
|
|
|
|
/// don't have to worry about the lifetime of the objects.
|
|
|
|
/// @brief LLVM Constant Representation
|
2002-04-28 19:55:58 +00:00
|
|
|
class Constant : public User {
|
2005-12-17 00:19:22 +00:00
|
|
|
void operator=(const Constant &); // Do not implement
|
|
|
|
Constant(const Constant &); // Do not implement
|
2002-04-28 19:55:58 +00:00
|
|
|
protected:
|
2008-05-19 20:15:12 +00:00
|
|
|
Constant(const Type *ty, ValueTy vty, Use *Ops, unsigned NumOps)
|
|
|
|
: User(ty, vty, Ops, NumOps) {}
|
2002-04-28 19:55:58 +00:00
|
|
|
|
|
|
|
void destroyConstantImpl();
|
|
|
|
public:
|
2002-08-25 22:54:55 +00:00
|
|
|
/// Static constructor to get a '0' constant of arbitrary type...
|
2002-10-09 23:12:25 +00:00
|
|
|
///
|
2002-04-28 19:55:58 +00:00
|
|
|
static Constant *getNullValue(const Type *Ty);
|
|
|
|
|
2007-06-15 06:10:53 +00:00
|
|
|
/// Static constructor to get a '-1' constant. This supports integers and
|
|
|
|
/// vectors.
|
|
|
|
///
|
|
|
|
static Constant *getAllOnesValue(const Type *Ty);
|
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// isNullValue - Return true if this is the value that would be returned by
|
|
|
|
/// getNullValue.
|
2002-04-28 19:55:58 +00:00
|
|
|
virtual bool isNullValue() const = 0;
|
|
|
|
|
|
|
|
virtual void print(std::ostream &O) const;
|
2006-12-17 05:15:13 +00:00
|
|
|
void print(std::ostream *O) const { if (O) print(*O); }
|
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 canTrap() const;
|
2002-04-28 19:55:58 +00:00
|
|
|
|
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 ContainsRelocations() const;
|
|
|
|
|
2004-08-04 02:43:00 +00:00
|
|
|
// Specialize get/setOperand for Constant's as their operands are always
|
|
|
|
// constants as well.
|
2005-04-21 20:19:05 +00:00
|
|
|
Constant *getOperand(unsigned i) {
|
2004-08-04 02:43:00 +00:00
|
|
|
return static_cast<Constant*>(User::getOperand(i));
|
|
|
|
}
|
|
|
|
const Constant *getOperand(unsigned i) const {
|
|
|
|
return static_cast<const Constant*>(User::getOperand(i));
|
|
|
|
}
|
|
|
|
void setOperand(unsigned i, Constant *C) {
|
|
|
|
User::setOperand(i, C);
|
|
|
|
}
|
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// destroyConstant - Called if some element of this constant is no longer
|
|
|
|
/// valid. At this point only other constants may be on the use_list for this
|
|
|
|
/// constant. Any constants on our Use list must also be destroy'd. The
|
|
|
|
/// implementation must be sure to remove the constant from the list of
|
|
|
|
/// available cached constants. Implementations should call
|
|
|
|
/// destroyConstantImpl as the last thing they do, to destroy all users and
|
|
|
|
/// delete this.
|
2002-08-18 00:39:59 +00:00
|
|
|
virtual void destroyConstant() { assert(0 && "Not reached!"); }
|
2005-04-21 20:19:05 +00:00
|
|
|
|
2002-10-09 23:12:25 +00:00
|
|
|
//// Methods for support type inquiry through isa, cast, and dyn_cast:
|
2002-04-28 19:55:58 +00:00
|
|
|
static inline bool classof(const Constant *) { return true; }
|
2004-07-17 23:26:12 +00:00
|
|
|
static inline bool classof(const GlobalValue *) { return true; }
|
2002-04-28 19:55:58 +00:00
|
|
|
static inline bool classof(const Value *V) {
|
2007-04-13 18:12:09 +00:00
|
|
|
return V->getValueID() >= ConstantFirstVal &&
|
|
|
|
V->getValueID() <= ConstantLastVal;
|
2002-04-28 19:55:58 +00:00
|
|
|
}
|
2002-07-14 22:46:32 +00:00
|
|
|
|
2002-10-09 23:12:25 +00:00
|
|
|
/// replaceUsesOfWithOnConstant - This method is a special form of
|
|
|
|
/// User::replaceUsesOfWith (which does not work on constants) that does work
|
|
|
|
/// on constants. Basically this method goes through the trouble of building
|
|
|
|
/// a new constant that is equivalent to the current one, with all uses of
|
|
|
|
/// From replaced with uses of To. After this construction is completed, all
|
|
|
|
/// of the users of 'this' are replaced to use the new constant, and then
|
|
|
|
/// 'this' is deleted. In general, you should not call this method, instead,
|
|
|
|
/// use Value::replaceAllUsesWith, which automatically dispatches to this
|
|
|
|
/// method as needed.
|
|
|
|
///
|
2005-10-25 17:59:28 +00:00
|
|
|
virtual void replaceUsesOfWithOnConstant(Value *, Value *, Use *) {
|
2002-10-09 23:12:25 +00:00
|
|
|
// Provide a default implementation for constants (like integers) that
|
|
|
|
// cannot use any other values. This cannot be called at runtime, but needs
|
|
|
|
// to be here to avoid link errors.
|
|
|
|
assert(getNumOperands() == 0 && "replaceUsesOfWithOnConstant must be "
|
|
|
|
"implemented for all constants that have operands!");
|
|
|
|
assert(0 && "Constants that do not have operands cannot be using 'From'!");
|
|
|
|
}
|
2004-11-19 16:39:04 +00:00
|
|
|
|
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 getStringValue(bool Chop = true, unsigned Offset = 0);
|
2002-04-28 19:55:58 +00:00
|
|
|
};
|
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
} // End llvm namespace
|
|
|
|
|
2002-04-28 19:55:58 +00:00
|
|
|
#endif
|