2003-09-30 18:37:50 +00:00
|
|
|
//===-- llvm/Value.h - Definition of the Value class ------------*- 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
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2006-06-05 16:29:06 +00:00
|
|
|
// This file declares the Value class.
|
2001-10-01 13:58:13 +00:00
|
|
|
//
|
2001-06-06 20:29:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2013-01-10 00:45:19 +00:00
|
|
|
#ifndef LLVM_IR_VALUE_H
|
|
|
|
#define LLVM_IR_VALUE_H
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Use.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/Casting.h"
|
2013-05-01 20:59:00 +00:00
|
|
|
#include "llvm/Support/CBindingWrapping.h"
|
2012-09-16 21:50:09 +00:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2013-05-01 20:59:00 +00:00
|
|
|
#include "llvm-c/Core.h"
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
namespace llvm {
|
|
|
|
|
2013-08-22 11:25:11 +00:00
|
|
|
class APInt;
|
2002-04-09 19:59:31 +00:00
|
|
|
class Argument;
|
2013-08-22 11:25:11 +00:00
|
|
|
class AssemblyAnnotationWriter;
|
2004-10-27 16:14:51 +00:00
|
|
|
class BasicBlock;
|
2013-08-22 11:25:11 +00:00
|
|
|
class Constant;
|
|
|
|
class DataLayout;
|
2002-03-23 22:51:58 +00:00
|
|
|
class Function;
|
2007-04-25 14:27:10 +00:00
|
|
|
class GlobalAlias;
|
2013-08-22 11:25:11 +00:00
|
|
|
class GlobalValue;
|
|
|
|
class GlobalVariable;
|
2006-01-26 01:54:21 +00:00
|
|
|
class InlineAsm;
|
2013-08-22 11:25:11 +00:00
|
|
|
class Instruction;
|
2009-08-11 17:45:13 +00:00
|
|
|
class LLVMContext;
|
2009-12-31 01:32:41 +00:00
|
|
|
class MDNode;
|
2012-03-26 06:58:25 +00:00
|
|
|
class StringRef;
|
2013-08-22 11:25:11 +00:00
|
|
|
class Twine;
|
|
|
|
class Type;
|
|
|
|
class ValueHandleBase;
|
|
|
|
class ValueSymbolTable;
|
|
|
|
class raw_ostream;
|
|
|
|
|
|
|
|
template<typename ValueTy> class StringMapEntry;
|
|
|
|
typedef StringMapEntry<Value*> ValueName;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Value Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-06-05 16:29:06 +00:00
|
|
|
/// This is a very important LLVM class. It is the base class of all values
|
|
|
|
/// computed by a program that may be used as operands to other values. Value is
|
|
|
|
/// the super class of other important classes such as Instruction and Function.
|
2011-03-08 16:59:03 +00:00
|
|
|
/// All Values have a Type. Type is not a subclass of Value. Some values can
|
|
|
|
/// have a name and they belong to some Module. Setting the name on the Value
|
2008-03-14 22:03:02 +00:00
|
|
|
/// automatically updates the module's symbol table.
|
2002-08-25 22:54:55 +00:00
|
|
|
///
|
2006-06-05 16:29:06 +00:00
|
|
|
/// Every value has a "use list" that keeps track of which other Values are
|
2009-03-31 22:11:05 +00:00
|
|
|
/// using this Value. A Value can also have an arbitrary number of ValueHandle
|
2009-12-29 02:14:09 +00:00
|
|
|
/// objects that watch it and listen to RAUW and Destroy events. See
|
2009-03-31 22:11:05 +00:00
|
|
|
/// llvm/Support/ValueHandle.h for details.
|
|
|
|
///
|
2006-06-05 16:29:06 +00:00
|
|
|
/// @brief LLVM Value Representation
|
2004-09-23 14:49:45 +00:00
|
|
|
class Value {
|
2009-03-31 07:25:22 +00:00
|
|
|
const unsigned char SubclassID; // Subclass identifier (for isa/dyn_cast)
|
2009-03-31 22:11:05 +00:00
|
|
|
unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this?
|
2005-02-05 01:37:44 +00:00
|
|
|
protected:
|
2009-07-17 17:16:59 +00:00
|
|
|
/// SubclassOptionalData - This member is similar to SubclassData, however it
|
|
|
|
/// is for holding information which may be used to aid optimization, but
|
|
|
|
/// which may be cleared to zero without affecting conservative
|
|
|
|
/// interpretation.
|
|
|
|
unsigned char SubclassOptionalData : 7;
|
|
|
|
|
2009-12-29 02:14:09 +00:00
|
|
|
private:
|
2005-02-05 01:37:44 +00:00
|
|
|
/// SubclassData - This member is defined by this class, but is not used for
|
|
|
|
/// anything. Subclasses can use it to hold whatever state they find useful.
|
|
|
|
/// This field is initialized to zero by the ctor.
|
|
|
|
unsigned short SubclassData;
|
2009-12-29 02:14:09 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Type *VTy;
|
2005-02-01 01:22:06 +00:00
|
|
|
Use *UseList;
|
2005-03-06 02:10:40 +00:00
|
|
|
|
2006-01-10 09:45:57 +00:00
|
|
|
friend class ValueSymbolTable; // Allow ValueSymbolTable to directly mod Name.
|
2009-03-31 22:11:05 +00:00
|
|
|
friend class ValueHandleBase;
|
2007-02-12 05:18:08 +00:00
|
|
|
ValueName *Name;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2012-09-16 21:37:56 +00:00
|
|
|
void operator=(const Value &) LLVM_DELETED_FUNCTION;
|
|
|
|
Value(const Value &) LLVM_DELETED_FUNCTION;
|
2004-06-26 20:33:27 +00:00
|
|
|
|
2009-09-23 01:33:16 +00:00
|
|
|
protected:
|
|
|
|
/// printCustom - Value subclasses can override this to implement custom
|
|
|
|
/// printing behavior.
|
|
|
|
virtual void printCustom(raw_ostream &O) const;
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Value(Type *Ty, unsigned scid);
|
2010-06-21 16:46:37 +00:00
|
|
|
public:
|
2001-06-06 20:29:01 +00:00
|
|
|
virtual ~Value();
|
2005-04-21 20:19:05 +00:00
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// dump - Support for debugging, callable in GDB: V->dump()
|
|
|
|
//
|
2009-09-23 01:33:16 +00:00
|
|
|
void dump() const;
|
2002-04-08 21:51:32 +00:00
|
|
|
|
2008-08-23 22:23:09 +00:00
|
|
|
/// print - Implement operator<< on Value.
|
2002-08-25 22:54:55 +00:00
|
|
|
///
|
2008-08-23 22:23:09 +00:00
|
|
|
void print(raw_ostream &O, AssemblyAnnotationWriter *AAW = 0) const;
|
2005-04-21 20:19:05 +00:00
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// All values are typed, get the type of this value.
|
|
|
|
///
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Type *getType() const { return VTy; }
|
2005-04-21 20:19:05 +00:00
|
|
|
|
2009-07-22 00:24:57 +00:00
|
|
|
/// All values hold a context through their type.
|
|
|
|
LLVMContext &getContext() const;
|
|
|
|
|
2012-04-10 20:12:16 +00:00
|
|
|
// All values can potentially be named.
|
|
|
|
bool hasName() const { return Name != 0 && SubclassID != MDStringVal; }
|
2007-08-10 15:34:35 +00:00
|
|
|
ValueName *getValueName() const { return Name; }
|
2012-04-10 20:12:16 +00:00
|
|
|
void setValueName(ValueName *VN) { Name = VN; }
|
2007-08-10 15:34:35 +00:00
|
|
|
|
2009-07-26 00:51:56 +00:00
|
|
|
/// getName() - Return a constant reference to the value's name. This is cheap
|
|
|
|
/// and guaranteed to return the same reference as long as the value is not
|
|
|
|
/// modified.
|
|
|
|
StringRef getName() const;
|
|
|
|
|
2009-07-26 00:34:27 +00:00
|
|
|
/// setName() - Change the name of the value, choosing a new unique name if
|
|
|
|
/// the provided name is taken.
|
|
|
|
///
|
2012-09-13 12:34:29 +00:00
|
|
|
/// \param Name The new name; or "" if the value's name should be removed.
|
2009-07-25 04:41:11 +00:00
|
|
|
void setName(const Twine &Name);
|
2007-02-13 07:53:34 +00:00
|
|
|
|
2007-02-11 00:37:27 +00:00
|
|
|
|
|
|
|
/// takeName - transfer the name from V to this value, setting V's name to
|
|
|
|
/// empty. It is an error to call V->takeName(V).
|
|
|
|
void takeName(Value *V);
|
2005-04-21 20:19:05 +00:00
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// replaceAllUsesWith - Go through the uses list for this definition and make
|
2005-04-21 20:19:05 +00:00
|
|
|
/// each use point to "V" instead of "this". After this completes, 'this's
|
2002-08-25 22:54:55 +00:00
|
|
|
/// use list is guaranteed to be empty.
|
|
|
|
///
|
|
|
|
void replaceAllUsesWith(Value *V);
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
2008-09-13 18:51:27 +00:00
|
|
|
// Methods for handling the chain of uses of this Value.
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2005-02-01 01:22:06 +00:00
|
|
|
typedef value_use_iterator<User> use_iterator;
|
2010-03-25 23:06:16 +00:00
|
|
|
typedef value_use_iterator<const User> const_use_iterator;
|
2005-02-01 01:22:06 +00:00
|
|
|
|
2008-09-19 15:13:20 +00:00
|
|
|
bool use_empty() const { return UseList == 0; }
|
2005-02-01 01:22:06 +00:00
|
|
|
use_iterator use_begin() { return use_iterator(UseList); }
|
2010-03-25 23:06:16 +00:00
|
|
|
const_use_iterator use_begin() const { return const_use_iterator(UseList); }
|
2005-02-01 01:22:06 +00:00
|
|
|
use_iterator use_end() { return use_iterator(0); }
|
2010-03-25 23:06:16 +00:00
|
|
|
const_use_iterator use_end() const { return const_use_iterator(0); }
|
2005-02-01 01:22:06 +00:00
|
|
|
User *use_back() { return *use_begin(); }
|
2008-09-13 18:51:27 +00:00
|
|
|
const User *use_back() const { return *use_begin(); }
|
2003-10-15 16:39:04 +00:00
|
|
|
|
2003-10-16 16:53:04 +00:00
|
|
|
/// hasOneUse - Return true if there is exactly one user of this value. This
|
|
|
|
/// is specialized because it is a common request and does not require
|
|
|
|
/// traversing the whole use list.
|
2003-10-15 16:39:04 +00:00
|
|
|
///
|
2003-10-16 16:53:04 +00:00
|
|
|
bool hasOneUse() const {
|
2010-03-25 23:06:16 +00:00
|
|
|
const_use_iterator I = use_begin(), E = use_end();
|
2003-10-16 16:53:04 +00:00
|
|
|
if (I == E) return false;
|
|
|
|
return ++I == E;
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2005-02-01 01:22:06 +00:00
|
|
|
/// hasNUses - Return true if this Value has exactly N users.
|
|
|
|
///
|
|
|
|
bool hasNUses(unsigned N) const;
|
|
|
|
|
2005-02-23 16:50:59 +00:00
|
|
|
/// hasNUsesOrMore - Return true if this value has N users or more. This is
|
|
|
|
/// logically equivalent to getNumUses() >= N.
|
|
|
|
///
|
|
|
|
bool hasNUsesOrMore(unsigned N) const;
|
|
|
|
|
2008-09-25 22:42:01 +00:00
|
|
|
bool isUsedInBasicBlock(const BasicBlock *BB) const;
|
2008-06-12 21:15:59 +00:00
|
|
|
|
2005-02-01 01:22:06 +00:00
|
|
|
/// getNumUses - This method computes the number of uses of this Value. This
|
2011-08-11 00:22:48 +00:00
|
|
|
/// is a linear time operation. Use hasOneUse, hasNUses, or hasNUsesOrMore
|
2005-02-23 16:50:59 +00:00
|
|
|
/// to check for specific values.
|
2005-02-01 01:22:06 +00:00
|
|
|
unsigned getNumUses() const;
|
|
|
|
|
2008-03-07 22:24:41 +00:00
|
|
|
/// addUse - This method should only be used by the Use class.
|
2003-10-16 16:53:04 +00:00
|
|
|
///
|
2010-12-20 22:28:03 +00:00
|
|
|
void addUse(Use &U) { U.addToList(&UseList); }
|
2004-06-26 20:33:27 +00:00
|
|
|
|
2006-06-05 16:29:06 +00:00
|
|
|
/// An enumeration for keeping track of the concrete subclass of Value that
|
|
|
|
/// is actually instantiated. Values of this enumeration are kept in the
|
|
|
|
/// Value classes SubclassID field. They are used for concrete type
|
|
|
|
/// identification.
|
2004-06-26 20:33:27 +00:00
|
|
|
enum ValueTy {
|
2004-07-19 00:57:40 +00:00
|
|
|
ArgumentVal, // This is an instance of Argument
|
|
|
|
BasicBlockVal, // This is an instance of BasicBlock
|
|
|
|
FunctionVal, // This is an instance of Function
|
2007-04-25 14:27:10 +00:00
|
|
|
GlobalAliasVal, // This is an instance of GlobalAlias
|
2004-07-19 00:57:40 +00:00
|
|
|
GlobalVariableVal, // This is an instance of GlobalVariable
|
2004-10-16 18:06:07 +00:00
|
|
|
UndefValueVal, // This is an instance of UndefValue
|
2009-10-28 00:01:44 +00:00
|
|
|
BlockAddressVal, // This is an instance of BlockAddress
|
2004-07-19 00:57:40 +00:00
|
|
|
ConstantExprVal, // This is an instance of ConstantExpr
|
2010-05-29 06:11:16 +00:00
|
|
|
ConstantAggregateZeroVal, // This is an instance of ConstantAggregateZero
|
2012-01-23 22:57:10 +00:00
|
|
|
ConstantDataArrayVal, // This is an instance of ConstantDataArray
|
|
|
|
ConstantDataVectorVal, // This is an instance of ConstantDataVector
|
2006-10-20 07:07:24 +00:00
|
|
|
ConstantIntVal, // This is an instance of ConstantInt
|
2005-09-27 06:08:32 +00:00
|
|
|
ConstantFPVal, // This is an instance of ConstantFP
|
|
|
|
ConstantArrayVal, // This is an instance of ConstantArray
|
|
|
|
ConstantStructVal, // This is an instance of ConstantStruct
|
2007-02-15 03:39:18 +00:00
|
|
|
ConstantVectorVal, // This is an instance of ConstantVector
|
2005-09-27 06:08:32 +00:00
|
|
|
ConstantPointerNullVal, // This is an instance of ConstantPointerNull
|
2009-04-04 07:22:01 +00:00
|
|
|
MDNodeVal, // This is an instance of MDNode
|
2009-07-22 17:43:22 +00:00
|
|
|
MDStringVal, // This is an instance of MDString
|
2006-01-24 04:13:11 +00:00
|
|
|
InlineAsmVal, // This is an instance of InlineAsm
|
2008-02-06 22:27:42 +00:00
|
|
|
PseudoSourceValueVal, // This is an instance of PseudoSourceValue
|
2009-11-12 21:04:19 +00:00
|
|
|
FixedStackPseudoSourceValueVal, // This is an instance of
|
|
|
|
// FixedStackPseudoSourceValue
|
2009-11-13 22:24:13 +00:00
|
|
|
InstructionVal, // This is an instance of Instruction
|
|
|
|
// Enum values starting at InstructionVal are used for Instructions;
|
|
|
|
// don't add new values here!
|
2009-11-12 21:04:19 +00:00
|
|
|
|
2005-09-27 06:08:32 +00:00
|
|
|
// Markers:
|
|
|
|
ConstantFirstVal = FunctionVal,
|
2009-07-23 01:07:34 +00:00
|
|
|
ConstantLastVal = ConstantPointerNullVal
|
2004-06-26 20:33:27 +00:00
|
|
|
};
|
2006-06-05 16:29:06 +00:00
|
|
|
|
2007-04-13 18:12:09 +00:00
|
|
|
/// getValueID - Return an ID for the concrete type of this object. This is
|
2006-06-05 16:29:06 +00:00
|
|
|
/// used to implement the classof checks. This should not be used for any
|
|
|
|
/// other purpose, as the values may change as LLVM evolves. Also, note that
|
2007-03-05 23:06:32 +00:00
|
|
|
/// for instructions, the Instruction's opcode is added to InstructionVal. So
|
|
|
|
/// this means three things:
|
|
|
|
/// # there is no value with code InstructionVal (no opcode==0).
|
|
|
|
/// # there are more possible values for the value type than in ValueTy enum.
|
|
|
|
/// # the InstructionVal enumerator must be the highest valued enumerator in
|
|
|
|
/// the ValueTy enum.
|
2007-04-13 18:12:09 +00:00
|
|
|
unsigned getValueID() const {
|
2004-06-26 20:33:27 +00:00
|
|
|
return SubclassID;
|
|
|
|
}
|
2004-06-27 18:38:24 +00:00
|
|
|
|
2009-09-07 23:54:19 +00:00
|
|
|
/// getRawSubclassOptionalData - Return the raw optional flags value
|
|
|
|
/// contained in this value. This should only be used when testing two
|
|
|
|
/// Values for equivalence.
|
|
|
|
unsigned getRawSubclassOptionalData() const {
|
|
|
|
return SubclassOptionalData;
|
|
|
|
}
|
|
|
|
|
2011-02-02 02:02:34 +00:00
|
|
|
/// clearSubclassOptionalData - Clear the optional flags contained in
|
|
|
|
/// this value.
|
|
|
|
void clearSubclassOptionalData() {
|
|
|
|
SubclassOptionalData = 0;
|
|
|
|
}
|
|
|
|
|
2009-08-25 22:11:20 +00:00
|
|
|
/// hasSameSubclassOptionalData - Test whether the optional flags contained
|
|
|
|
/// in this value are equal to the optional flags in the given value.
|
|
|
|
bool hasSameSubclassOptionalData(const Value *V) const {
|
|
|
|
return SubclassOptionalData == V->SubclassOptionalData;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// intersectOptionalDataWith - Clear any optional flags in this value
|
|
|
|
/// that are not also set in the given value.
|
|
|
|
void intersectOptionalDataWith(const Value *V) {
|
|
|
|
SubclassOptionalData &= V->SubclassOptionalData;
|
|
|
|
}
|
|
|
|
|
2010-07-15 05:14:01 +00:00
|
|
|
/// hasValueHandle - Return true if there is a value handle associated with
|
|
|
|
/// this value.
|
|
|
|
bool hasValueHandle() const { return HasValueHandle; }
|
2004-07-30 06:59:15 +00:00
|
|
|
|
2013-08-22 10:12:18 +00:00
|
|
|
/// \brief Strips off any unneeded pointer casts, all-zero GEPs and aliases
|
|
|
|
/// from the specified value, returning the original uncasted value.
|
|
|
|
///
|
|
|
|
/// If this is called on a non-pointer value, it returns 'this'.
|
2008-05-07 22:54:15 +00:00
|
|
|
Value *stripPointerCasts();
|
2008-06-16 06:43:06 +00:00
|
|
|
const Value *stripPointerCasts() const {
|
|
|
|
return const_cast<Value*>(this)->stripPointerCasts();
|
|
|
|
}
|
2008-10-01 15:25:41 +00:00
|
|
|
|
2013-08-22 10:12:18 +00:00
|
|
|
/// \brief Strips off any unneeded pointer casts and all-zero GEPs from the
|
|
|
|
/// specified value, returning the original uncasted value.
|
|
|
|
///
|
|
|
|
/// If this is called on a non-pointer value, it returns 'this'.
|
2013-05-06 01:48:55 +00:00
|
|
|
Value *stripPointerCastsNoFollowAliases();
|
|
|
|
const Value *stripPointerCastsNoFollowAliases() const {
|
|
|
|
return const_cast<Value*>(this)->stripPointerCastsNoFollowAliases();
|
|
|
|
}
|
|
|
|
|
2013-08-22 10:12:18 +00:00
|
|
|
/// \brief Strips off unneeded pointer casts and all-constant GEPs from the
|
|
|
|
/// specified value, returning the original pointer value.
|
|
|
|
///
|
|
|
|
/// If this is called on a non-pointer value, it returns 'this'.
|
2012-03-14 23:19:53 +00:00
|
|
|
Value *stripInBoundsConstantOffsets();
|
|
|
|
const Value *stripInBoundsConstantOffsets() const {
|
|
|
|
return const_cast<Value*>(this)->stripInBoundsConstantOffsets();
|
2012-03-10 08:39:09 +00:00
|
|
|
}
|
|
|
|
|
2013-08-22 11:25:11 +00:00
|
|
|
/// \brief Strips like \c stripInBoundsConstantOffsets but also accumulates
|
|
|
|
/// the constant offset stripped.
|
|
|
|
///
|
|
|
|
/// Stores the resulting constant offset stripped into the APInt provided.
|
|
|
|
/// The provided APInt will be extended or truncated as needed to be the
|
|
|
|
/// correct bitwidth for an offset of this pointer type.
|
|
|
|
///
|
|
|
|
/// If this is called on a non-pointer value, it returns 'this'.
|
|
|
|
Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
|
|
|
|
APInt &Offset);
|
|
|
|
const Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
|
|
|
|
APInt &Offset) const {
|
|
|
|
return const_cast<Value *>(this)
|
|
|
|
->stripAndAccumulateInBoundsConstantOffsets(DL, Offset);
|
|
|
|
}
|
|
|
|
|
2013-08-22 10:12:18 +00:00
|
|
|
/// \brief Strips off unneeded pointer casts and any in-bounds offsets from
|
|
|
|
/// the specified value, returning the original pointer value.
|
|
|
|
///
|
|
|
|
/// If this is called on a non-pointer value, it returns 'this'.
|
2012-03-10 08:39:09 +00:00
|
|
|
Value *stripInBoundsOffsets();
|
|
|
|
const Value *stripInBoundsOffsets() const {
|
|
|
|
return const_cast<Value*>(this)->stripInBoundsOffsets();
|
|
|
|
}
|
|
|
|
|
2010-11-11 21:23:25 +00:00
|
|
|
/// isDereferenceablePointer - Test if this value is always a pointer to
|
|
|
|
/// allocated and suitably aligned memory for a simple load or store.
|
|
|
|
bool isDereferenceablePointer() const;
|
2008-12-02 07:16:45 +00:00
|
|
|
|
2008-12-02 18:33:11 +00:00
|
|
|
/// DoPHITranslation - If this value is a PHI node with CurBB as its parent,
|
2008-12-02 07:16:45 +00:00
|
|
|
/// return the value in the PHI node corresponding to PredBB. If not, return
|
|
|
|
/// ourself. This is useful if you want to know the value something has in a
|
|
|
|
/// predecessor block.
|
|
|
|
Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB);
|
|
|
|
|
|
|
|
const Value *DoPHITranslation(const BasicBlock *CurBB,
|
|
|
|
const BasicBlock *PredBB) const{
|
|
|
|
return const_cast<Value*>(this)->DoPHITranslation(CurBB, PredBB);
|
|
|
|
}
|
2009-12-29 02:14:09 +00:00
|
|
|
|
2010-07-30 21:07:05 +00:00
|
|
|
/// MaximumAlignment - This is the greatest alignment value supported by
|
|
|
|
/// load, store, and alloca instructions, and global values.
|
|
|
|
static const unsigned MaximumAlignment = 1u << 29;
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
/// mutateType - Mutate the type of this Value to be of the specified type.
|
|
|
|
/// Note that this is an extremely dangerous operation which can create
|
|
|
|
/// completely invalid IR very easily. It is strongly recommended that you
|
|
|
|
/// recreate IR objects with the right types instead of mutating them in
|
|
|
|
/// place.
|
|
|
|
void mutateType(Type *Ty) {
|
|
|
|
VTy = Ty;
|
|
|
|
}
|
|
|
|
|
2009-12-29 02:14:09 +00:00
|
|
|
protected:
|
|
|
|
unsigned short getSubclassDataFromValue() const { return SubclassData; }
|
|
|
|
void setValueSubclassData(unsigned short D) { SubclassData = D; }
|
2001-06-06 20:29:01 +00:00
|
|
|
};
|
|
|
|
|
2008-08-23 22:23:09 +00:00
|
|
|
inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
|
|
|
|
V.print(OS);
|
|
|
|
return OS;
|
|
|
|
}
|
|
|
|
|
2005-04-21 20:19:05 +00:00
|
|
|
void Use::set(Value *V) {
|
2008-09-19 15:13:20 +00:00
|
|
|
if (Val) removeFromList();
|
|
|
|
Val = V;
|
2003-10-16 16:53:04 +00:00
|
|
|
if (V) V->addUse(*this);
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2001-10-01 18:26:53 +00:00
|
|
|
|
2002-04-08 21:51:32 +00:00
|
|
|
// isa - Provide some specializations of isa so that we don't have to include
|
|
|
|
// the subtype header files to test to see if the value is a subclass...
|
2001-10-01 18:26:53 +00:00
|
|
|
//
|
2010-03-30 18:05:52 +00:00
|
|
|
template <> struct isa_impl<Constant, Value> {
|
|
|
|
static inline bool doit(const Value &Val) {
|
|
|
|
return Val.getValueID() >= Value::ConstantFirstVal &&
|
|
|
|
Val.getValueID() <= Value::ConstantLastVal;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct isa_impl<Argument, Value> {
|
|
|
|
static inline bool doit (const Value &Val) {
|
|
|
|
return Val.getValueID() == Value::ArgumentVal;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct isa_impl<InlineAsm, Value> {
|
|
|
|
static inline bool doit(const Value &Val) {
|
|
|
|
return Val.getValueID() == Value::InlineAsmVal;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct isa_impl<Instruction, Value> {
|
|
|
|
static inline bool doit(const Value &Val) {
|
|
|
|
return Val.getValueID() >= Value::InstructionVal;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct isa_impl<BasicBlock, Value> {
|
|
|
|
static inline bool doit(const Value &Val) {
|
|
|
|
return Val.getValueID() == Value::BasicBlockVal;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct isa_impl<Function, Value> {
|
|
|
|
static inline bool doit(const Value &Val) {
|
|
|
|
return Val.getValueID() == Value::FunctionVal;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct isa_impl<GlobalVariable, Value> {
|
|
|
|
static inline bool doit(const Value &Val) {
|
|
|
|
return Val.getValueID() == Value::GlobalVariableVal;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct isa_impl<GlobalAlias, Value> {
|
|
|
|
static inline bool doit(const Value &Val) {
|
|
|
|
return Val.getValueID() == Value::GlobalAliasVal;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct isa_impl<GlobalValue, Value> {
|
|
|
|
static inline bool doit(const Value &Val) {
|
|
|
|
return isa<GlobalVariable>(Val) || isa<Function>(Val) ||
|
|
|
|
isa<GlobalAlias>(Val);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct isa_impl<MDNode, Value> {
|
|
|
|
static inline bool doit(const Value &Val) {
|
|
|
|
return Val.getValueID() == Value::MDNodeVal;
|
|
|
|
}
|
|
|
|
};
|
2009-03-29 05:45:43 +00:00
|
|
|
|
|
|
|
// Value* is only 4-byte aligned.
|
|
|
|
template<>
|
|
|
|
class PointerLikeTypeTraits<Value*> {
|
|
|
|
typedef Value* PT;
|
|
|
|
public:
|
|
|
|
static inline void *getAsVoidPointer(PT P) { return P; }
|
|
|
|
static inline PT getFromVoidPointer(void *P) {
|
|
|
|
return static_cast<PT>(P);
|
|
|
|
}
|
|
|
|
enum { NumLowBitsAvailable = 2 };
|
|
|
|
};
|
2001-10-01 18:26:53 +00:00
|
|
|
|
2013-05-01 20:59:00 +00:00
|
|
|
// Create wrappers for C Binding types (see CBindingWrapping.h).
|
|
|
|
DEFINE_ISA_CONVERSION_FUNCTIONS(Value, LLVMValueRef)
|
|
|
|
|
|
|
|
/* Specialized opaque value conversions.
|
|
|
|
*/
|
|
|
|
inline Value **unwrap(LLVMValueRef *Vals) {
|
|
|
|
return reinterpret_cast<Value**>(Vals);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
|
|
|
|
#ifdef DEBUG
|
|
|
|
for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
|
|
|
|
cast<T>(*I);
|
|
|
|
#endif
|
|
|
|
(void)Length;
|
|
|
|
return reinterpret_cast<T**>(Vals);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline LLVMValueRef *wrap(const Value **Vals) {
|
|
|
|
return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
|
|
|
|
}
|
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
} // End llvm namespace
|
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
#endif
|