path: root/include/llvm/Constants.h

//===-- llvm/Constants.h - Constant class subclass definitions --*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
/// @file This file contains the declarations for the subclasses of Constant, 
/// which represent the different flavors of constant values that live in LLVM.
/// 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.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_CONSTANTS_H
#define LLVM_CONSTANTS_H

#include "llvm/Constant.h"
#include "llvm/Type.h"

namespace llvm {

class ArrayType;
class StructType;
class PointerType;
class PackedType;

template<class ConstantClass, class TypeClass, class ValType>
struct ConstantCreator;
template<class ConstantClass, class TypeClass>
struct ConvertConstantType;

//===----------------------------------------------------------------------===//
/// This is the shared superclass of boolean and integer constants. This class 
/// just defines some common interfaces to be implemented by the subclasses.
/// @brief An abstract class for integer constants.
class ConstantIntegral : public Constant {
protected:
  uint64_t Val;
  ConstantIntegral(const Type *Ty, ValueTy VT, uint64_t V);
public:
  /// Return the constant as a 64-bit unsigned integer value after it
  /// has been zero extended as appropriate for the type of this constant.
  /// @brief Return the zero extended value.
  inline uint64_t getZExtValue() const {
    return Val;
  }

  /// Return the constant as a 64-bit integer value after it has been sign
  /// sign extended as appropriate for the type of this constant.
  /// @brief Return the sign extended value.
  inline int64_t getSExtValue() const {
    unsigned Size = getType()->getPrimitiveSizeInBits();
    return (int64_t(Val) << (64-Size)) >> (64-Size);
  }
  
  /// This function is implemented by subclasses and will return true iff this
  /// constant represents the the "null" value that would be returned by the
  /// getNullValue method.
  /// @returns true if the constant's value is 0.
  /// @brief Determine if the value is null.
  virtual bool isNullValue() const = 0;

  /// This function is implemented by sublcasses and will return true iff this
  /// constant represents the the largest value that may be represented by this
  /// constant's type.
  /// @returns true if the constant's value is maximal.
  /// @brief Determine if the value is maximal.
  virtual bool isMaxValue() const = 0;

  /// This function is implemented by subclasses and will return true iff this 
  /// constant represents the smallest value that may be represented by this 
  /// constant's type.
  /// @returns true if the constant's value is minimal
  /// @brief Determine if the value is minimal.
  virtual bool isMinValue() const = 0;

  /// This function is implemented by subclasses and will return true iff every
  /// bit in this constant is set to true.
  /// @returns true if all bits of the constant are ones.
  /// @brief Determine if the value is all ones.
  virtual bool isAllOnesValue() const = 0;

  /// @returns the largest value for an integer constant of the given type 
  /// @brief Get the maximal value
  static ConstantIntegral *getMaxValue(const Type *Ty);

  /// @returns the smallest value for an integer constant of the given type 
  /// @brief Get the minimal value
  static ConstantIntegral *getMinValue(const Type *Ty);

  /// @returns the value for an integer constant of the given type that has all
  /// its bits set to true.
  /// @brief Get the all ones value
  static ConstantIntegral *getAllOnesValue(const Type *Ty);

  /// Methods to support type inquiry through isa, cast, and dyn_cast:
  static inline bool classof(const ConstantIntegral *) { return true; }
  static bool classof(const Value *V) {
    return V->getValueType() == ConstantBoolVal ||
           V->getValueType() == ConstantIntVal;
  }
};


//===----------------------------------------------------------------------===//
/// This concrete class represents constant values of type BoolTy. There are 
/// only two instances of this class constructed: the True and False static 
/// members. The constructor is hidden to ensure this invariant.
/// @brief Constant Boolean class
class ConstantBool : public ConstantIntegral {
  ConstantBool(bool V);
public:
  /// getTrue/getFalse - Return the singleton true/false values.
  static ConstantBool *getTrue();
  static ConstantBool *getFalse();

  /// This method is provided mostly for compatibility with the other 
  /// ConstantIntegral subclasses.
  /// @brief Static factory method for getting a ConstantBool instance.
  static ConstantBool *get(bool Value) { return Value ? getTrue() : getFalse();}

  /// This method is provided mostly for compatibility with the other 
  /// ConstantIntegral subclasses.
  /// @brief Static factory method for getting a ConstantBool instance.
  static ConstantBool *get(const Type *Ty, bool Value) { return get(Value); }

  /// Returns the opposite value of this ConstantBool value.
  /// @brief Get inverse value.
  inline ConstantBool *inverted() const {
    return getValue() ? getFalse() : getTrue();
  }

  /// @returns the value of this ConstantBool
  /// @brief return the boolean value of this constant.
  inline bool getValue() const { return static_cast<bool>(getZExtValue()); }

  /// @see ConstantIntegral for details
  /// @brief Implement overrides
  virtual bool isNullValue() const { return getValue() == false; }
  virtual bool isMaxValue() const { return getValue() == true; }
  virtual bool isMinValue() const { return getValue() == false; }
  virtual bool isAllOnesValue() const { return getValue() == true; }

  /// @brief Methods to support type inquiry through isa, cast, and dyn_cast:
  static inline bool classof(const ConstantBool *) { return true; }
  static bool classof(const Value *V) {
    return V->getValueType() == ConstantBoolVal;
  }
};


//===----------------------------------------------------------------------===//
/// This is concrete integer subclass of ConstantIntegral that represents 
/// both signed and unsigned integral constants, other than boolean.
/// @brief Class for constant integers.
class ConstantInt : public ConstantIntegral {
protected:
  ConstantInt(const ConstantInt &);      // DO NOT IMPLEMENT
  ConstantInt(const Type *Ty, uint64_t V);
  ConstantInt(const Type *Ty, int64_t V);
  friend struct ConstantCreator<ConstantInt, Type, uint64_t>;
public:
  /// A helper method that can be used to determine if the constant contained 
  /// within is equal to a constant.  This only works for very small values, 
  /// because this is all that can be represented with all types.
  /// @brief Determine if this constant's value is same as an unsigned char.
  bool equalsInt(unsigned char V) const {
    assert(V <= 127 &&
           "equalsInt: Can only be used with very small positive constants!");
    return Val == V;
  }

  /// Return a ConstantInt with the specified value for the specified type. The
  /// value V will be canonicalized to a uint64_t but accessing it with either
  /// getSExtValue() or getZExtValue() (ConstantIntegral) will yield the correct
  /// sized/signed value for the type Ty.
  /// @brief Get a ConstantInt for a specific value.
  static ConstantInt *get(const Type *Ty, int64_t V);

  /// This static method returns true if the type Ty is big enough to 
  /// represent the value V. This can be used to avoid having the get method 
  /// assert when V is larger than Ty can represent.
  /// @returns true if V is a valid value for type Ty
  /// @brief Determine if the value is in range for the given type.
  static bool isValueValidForType(const Type *Ty, int64_t V);

  /// @returns true if this is the null integer value.
  /// @see ConstantIntegral for details
  /// @brief Implement override.
  virtual bool isNullValue() const { return Val == 0; }

  /// @returns true iff this constant's bits are all set to true.
  /// @see ConstantIntegral
  /// @brief Override implementation
  virtual bool isAllOnesValue() const { return getSExtValue() == -1; }

  /// @returns true iff this is the largest value that may be represented 
  /// by this type.
  /// @see ConstantIntegeral
  /// @brief Override implementation
  virtual bool isMaxValue() const {
    if (getType()->isSigned()) {
      int64_t V = getSExtValue();
      if (V < 0) return false;    // Be careful about wrap-around on 'long's
      ++V;
      return !isValueValidForType(getType(), V) || V < 0;
    }
    return isAllOnesValue();
  }

  /// @returns true if this is the smallest value that may be represented by 
  /// this type.
  /// @see ConstantIntegral
  /// @brief Override implementation
  virtual bool isMinValue() const {
    if (getType()->isSigned())