- // Specialize get/setOperand for Constant's as their operands are always
- // constants as well.
- Constant *getOperand(unsigned i) {
- 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);
- }
+ /// isNegativeZeroValue - Return true if the value is what would be returned
+ /// by getZeroValueForNegation.
+ bool isNegativeZeroValue() const;
+
+ /// 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;
+
+ /// isThreadDependent - Return true if the value can vary between threads.
+ bool isThreadDependent() const;
+
+ /// isConstantUsed - Return true if the constant has users other than constant
+ /// exprs and other dangling things.
+ bool isConstantUsed() const;
+
+ enum PossibleRelocationsTy {
+ NoRelocation = 0,
+ LocalRelocation = 1,
+ GlobalRelocations = 2
+ };
+
+ /// getRelocationInfo - This method classifies the entry according to
+ /// whether or not it may generate a relocation entry. This must be
+ /// conservative, so if it might codegen to a relocatable entry, it should say
+ /// so. The return values are:
+ ///
+ /// NoRelocation: This constant pool entry is guaranteed to never have a
+ /// relocation applied to it (because it holds a simple constant like
+ /// '4').
+ /// LocalRelocation: This entry has relocations, but the entries are
+ /// guaranteed to be resolvable by the static linker, so the dynamic
+ /// linker will never see them.
+ /// GlobalRelocations: This entry may have arbitrary relocations.
+ ///
+ /// FIXME: This really should not be in VMCore.
+ PossibleRelocationsTy getRelocationInfo() const;
+
+ /// getAggregateElement - For aggregates (struct/array/vector) return the
+ /// constant that corresponds to the specified element if possible, or null if
+ /// not. This can return null if the element index is a ConstantExpr, or if
+ /// 'this' is a constant expr.
+ Constant *getAggregateElement(unsigned Elt) const;
+ Constant *getAggregateElement(Constant *Elt) const;
+
+ /// getSplatValue - If this is a splat vector constant, meaning that all of
+ /// the elements have the same value, return that value. Otherwise return 0.
+ Constant *getSplatValue() const;
+
+ /// If C is a constant integer then return its value, otherwise C must be a
+ /// vector of constant integers, all equal, and the common value is returned.
+ const APInt &getUniqueInteger() const;