include/llvm/ConstantHandling.h

   1 //===-- ConstantHandling.h - Stuff for manipulating constants ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // WARNING: These operators may return a null object if I don't know how to
  11 //          perform the specified operation on the specified constant types.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CONSTANTHANDLING_H
  16 #define LLVM_CONSTANTHANDLING_H
  17
  18 #include "llvm/Constants.h"
  19 #include "llvm/Type.h"
  20
  21 namespace llvm {
  22
  23 class PointerType;
  24
  25 struct ConstRules {
  26   ConstRules() {}
  27
  28   // Binary Operators...
  29   virtual Constant *add(const Constant *V1, const Constant *V2) const = 0;
  30   virtual Constant *sub(const Constant *V1, const Constant *V2) const = 0;
  31   virtual Constant *mul(const Constant *V1, const Constant *V2) const = 0;
  32   virtual Constant *div(const Constant *V1, const Constant *V2) const = 0;
  33   virtual Constant *rem(const Constant *V1, const Constant *V2) const = 0;
  34   virtual Constant *op_and(const Constant *V1, const Constant *V2) const = 0;
  35   virtual Constant *op_or (const Constant *V1, const Constant *V2) const = 0;
  36   virtual Constant *op_xor(const Constant *V1, const Constant *V2) const = 0;
  37   virtual Constant *shl(const Constant *V1, const Constant *V2) const = 0;
  38   virtual Constant *shr(const Constant *V1, const Constant *V2) const = 0;
  39
  40   virtual ConstantBool *lessthan(const Constant *V1,
  41                                  const Constant *V2) const = 0;
  42   virtual ConstantBool *equalto(const Constant *V1,
  43                                 const Constant *V2) const = 0;
  44
  45   // Casting operators.  ick
  46   virtual ConstantBool *castToBool  (const Constant *V) const = 0;
  47   virtual ConstantSInt *castToSByte (const Constant *V) const = 0;
  48   virtual ConstantUInt *castToUByte (const Constant *V) const = 0;
  49   virtual ConstantSInt *castToShort (const Constant *V) const = 0;
  50   virtual ConstantUInt *castToUShort(const Constant *V) const = 0;
  51   virtual ConstantSInt *castToInt   (const Constant *V) const = 0;
  52   virtual ConstantUInt *castToUInt  (const Constant *V) const = 0;
  53   virtual ConstantSInt *castToLong  (const Constant *V) const = 0;
  54   virtual ConstantUInt *castToULong (const Constant *V) const = 0;
  55   virtual ConstantFP   *castToFloat (const Constant *V) const = 0;
  56   virtual ConstantFP   *castToDouble(const Constant *V) const = 0;
  57   virtual Constant     *castToPointer(const Constant *V,
  58                                       const PointerType *Ty) const = 0;
  59
  60   inline Constant *castTo(const Constant *V, const Type *Ty) const {
  61     switch (Ty->getPrimitiveID()) {
  62     case Type::BoolTyID:   return castToBool(V);
  63     case Type::UByteTyID:  return castToUByte(V);
  64     case Type::SByteTyID:  return castToSByte(V);
  65     case Type::UShortTyID: return castToUShort(V);
  66     case Type::ShortTyID:  return castToShort(V);
  67     case Type::UIntTyID:   return castToUInt(V);
  68     case Type::IntTyID:    return castToInt(V);
  69     case Type::ULongTyID:  return castToULong(V);
  70     case Type::LongTyID:   return castToLong(V);
  71     case Type::FloatTyID:  return castToFloat(V);
  72     case Type::DoubleTyID: return castToDouble(V);
  73     case Type::PointerTyID:
  74       return castToPointer(V, reinterpret_cast<const PointerType*>(Ty));
  75     default: return 0;
  76     }
  77   }
  78
  79   // ConstRules::get - Return an instance of ConstRules for the specified
  80   // constant operands.
  81   //
  82   static ConstRules &get(const Constant *V1, const Constant *V2);
  83 private:
  84   ConstRules(const ConstRules &);             // Do not implement
  85   ConstRules &operator=(const ConstRules &);  // Do not implement
  86 };
  87
  88
  89 //===----------------------------------------------------------------------===//
  90 //  Implement higher level instruction folding type instructions
  91 //===----------------------------------------------------------------------===//
  92
  93 // Constant fold various types of instruction...
  94 Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy);
  95 Constant *ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *V1,
  96                                         const Constant *V2);
  97 Constant *ConstantFoldGetElementPtr(const Constant *C,
  98                                     const std::vector<Constant*> &IdxList);
  99
 100 } // End llvm namespace
 101
 102 #endif