void operator=(const Constant &); // Do not implement
Constant(const Constant &); // Do not implement
protected:
- Constant(const Type *Ty, ValueTy vty, Use *Ops, unsigned NumOps,
- const std::string& Name = "")
- : User(Ty, vty, Ops, NumOps, Name) {}
+ Constant(const Type *Ty, ValueTy vty, Use *Ops, unsigned NumOps)
+ : User(Ty, vty, Ops, NumOps) {}
void destroyConstantImpl();
public:
virtual bool isNullValue() const = 0;
virtual void print(std::ostream &O) const;
+ void print(std::ostream *O) const { if (O) print(*O); }
+
+ /// 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;
+
+ /// ContaintsRelocations - Return true if the constant value contains
+ /// relocations which cannot be resolved at compile time.
+ bool ContainsRelocations() const;
// Specialize get/setOperand for Constant's as their operands are always
// constants as well.
static inline bool classof(const Constant *) { return true; }
static inline bool classof(const GlobalValue *) { return true; }
static inline bool classof(const Value *V) {
- return V->getValueType() >= ConstantFirstVal &&
- V->getValueType() <= ConstantLastVal;
+ return V->getValueID() >= ConstantFirstVal &&
+ V->getValueID() <= ConstantLastVal;
}
/// replaceUsesOfWithOnConstant - This method is a special form of
assert(0 && "Constants that do not have operands cannot be using 'From'!");
}
- /// clearAllValueMaps - This method frees all internal memory used by the
- /// constant subsystem, which can be used in environments where this memory
- /// is otherwise reported as a leak.
- static void clearAllValueMaps();
-
/// 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.
/// Parameter Chop determines if the result is chopped at the first null