Constant.h revision be583b914d8156b99d3da264d5adca37fee8dbc9 
1//===-- llvm/Constant.h - Constant class definition --------------*- C++ -*--=//
2//
3// This file contains the declaration of the Constant class.
4//
5//===----------------------------------------------------------------------===//
6
7#ifndef LLVM_CONSTANT_H
8#define LLVM_CONSTANT_H
9
10#include <assert.h>
11#include "llvm/User.h"
12
13class Constant : public User {
14protected:
15  inline Constant(const Type *Ty) : User(Ty, Value::ConstantVal) {}
16  ~Constant() {}
17
18  void destroyConstantImpl();
19public:
20  // setName - Specialize setName to handle symbol table majik...
21  virtual void setName(const std::string &name, SymbolTable *ST = 0);
22
23  /// Static constructor to get a '0' constant of arbitrary type...
24  ///
25  static Constant *getNullValue(const Type *Ty);
26
27  /// isNullValue - Return true if this is the value that would be returned by
28  /// getNullValue.
29  virtual bool isNullValue() const = 0;
30
31  virtual void print(std::ostream &O) const;
32
33  /// isConstantExpr - Return true if this is a ConstantExpr
34  ///
35  virtual bool isConstantExpr() const { return false; }
36
37
38  /// destroyConstant - Called if some element of this constant is no longer
39  /// valid.  At this point only other constants may be on the use_list for this
40  /// constant.  Any constants on our Use list must also be destroy'd.  The
41  /// implementation must be sure to remove the constant from the list of
42  /// available cached constants.  Implementations should call
43  /// destroyConstantImpl as the last thing they do, to destroy all users and
44  /// delete this.
45  ///
46  /// Note that this call is only valid on non-primitive constants: You cannot
47  /// destroy an integer constant for example.  This API is used to delete
48  /// constants that have ConstantPointerRef's embeded in them when the module
49  /// is deleted, and it is used by GlobalDCE to remove ConstantPointerRefs that
50  /// are unneeded, allowing globals to be DCE'd.
51  ///
52  virtual void destroyConstant() { assert(0 && "Not reached!"); }
53
54
55  //// Methods for support type inquiry through isa, cast, and dyn_cast:
56  static inline bool classof(const Constant *) { return true; }
57  static inline bool classof(const Value *V) {
58    return V->getValueType() == Value::ConstantVal;
59  }
60
61  /// replaceUsesOfWithOnConstant - This method is a special form of
62  /// User::replaceUsesOfWith (which does not work on constants) that does work
63  /// on constants.  Basically this method goes through the trouble of building
64  /// a new constant that is equivalent to the current one, with all uses of
65  /// From replaced with uses of To.  After this construction is completed, all
66  /// of the users of 'this' are replaced to use the new constant, and then
67  /// 'this' is deleted.  In general, you should not call this method, instead,
68  /// use Value::replaceAllUsesWith, which automatically dispatches to this
69  /// method as needed.
70  ///
71  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To) {
72    // Provide a default implementation for constants (like integers) that
73    // cannot use any other values.  This cannot be called at runtime, but needs
74    // to be here to avoid link errors.
75    assert(getNumOperands() == 0 && "replaceUsesOfWithOnConstant must be "
76           "implemented for all constants that have operands!");
77    assert(0 && "Constants that do not have operands cannot be using 'From'!");
78  }
79
80  // WARNING: Only to be used by Bytecode & Assembly Parsers!  USER CODE SHOULD
81  // NOT USE THIS!!
82  // Returns the number of uses of OldV that were replaced.
83  unsigned mutateReferences(Value* OldV, Value *NewV);
84  // END WARNING!!
85};
86
87#endif
88