include/llvm/OperandTraits.h

   1 //===-- llvm/OperandTraits.h - OperandTraits class definition ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the traits classes that are handy for enforcing the correct
  11 // layout of various User subclasses. It also provides the means for accessing
  12 // the operands in the most efficient manner.
  13 //
  14
  15 #ifndef LLVM_OPERAND_TRAITS_H
  16 #define LLVM_OPERAND_TRAITS_H
  17
  18 #include "llvm/User.h"
  19
  20 namespace llvm {
  21
  22 //===----------------------------------------------------------------------===//
  23 //                          FixedNumOperands Trait Class
  24 //===----------------------------------------------------------------------===//
  25
  26 /// FixedNumOperandTraits - determine the allocation regime of the Use array
  27 /// when it is a prefix to the User object, and the number of Use objects is
  28 /// known at compile time.
  29
  30 template <unsigned ARITY>
  31 struct FixedNumOperandTraits {
  32   static Use *op_begin(User* U) {
  33     return reinterpret_cast<Use*>(U) - ARITY;
  34   }
  35   static Use *op_end(User* U) {
  36     return reinterpret_cast<Use*>(U);
  37   }
  38   static unsigned operands(const User*) {
  39     return ARITY;
  40   }
  41   struct prefix {
  42     Use Ops[ARITY];
  43     prefix(); // DO NOT IMPLEMENT
  44   };
  45   template <class U>
  46   struct Layout {
  47     struct overlay : prefix, U {
  48       overlay(); // DO NOT IMPLEMENT
  49     };
  50   };
  51   static inline void *allocate(unsigned); // FIXME
  52 };
  53
  54 //===----------------------------------------------------------------------===//
  55 //                          OptionalOperands Trait Class
  56 //===----------------------------------------------------------------------===//
  57
  58 template <unsigned ARITY = 1>
  59 struct OptionalOperandTraits : FixedNumOperandTraits<ARITY> {
  60   static unsigned operands(const User *U) {
  61     return U->getNumOperands();
  62   }
  63 };
  64
  65 //===----------------------------------------------------------------------===//
  66 //                          VariadicOperand Trait Class
  67 //===----------------------------------------------------------------------===//
  68
  69 /// VariadicOperandTraits - determine the allocation regime of the Use array
  70 /// when it is a prefix to the User object, and the number of Use objects is
  71 /// only known at allocation time.
  72
  73 template <unsigned MINARITY = 0>
  74 struct VariadicOperandTraits {
  75   static Use *op_begin(User* U) {
  76     return reinterpret_cast<Use*>(U) - U->getNumOperands();
  77   }
  78   static Use *op_end(User* U) {
  79     return reinterpret_cast<Use*>(U);
  80   }
  81   static unsigned operands(const User *U) {
  82     return U->getNumOperands();
  83   }
  84   static inline void *allocate(unsigned); // FIXME
  85 };
  86
  87 //===----------------------------------------------------------------------===//
  88 //                          HungoffOperand Trait Class
  89 //===----------------------------------------------------------------------===//
  90
  91 /// HungoffOperandTraits - determine the allocation regime of the Use array
  92 /// when it is not a prefix to the User object, but allocated at an unrelated
  93 /// heap address.
  94 /// Assumes that the User subclass that is determined by this traits class
  95 /// has an OperandList member of type User::op_iterator. [Note: this is now
  96 /// trivially satisfied, because User has that member for historic reasons.]
  97 ///
  98 /// This is the traits class that is needed when the Use array must be
  99 /// resizable.
 100
 101 template <unsigned MINARITY = 1>
 102 struct HungoffOperandTraits {
 103   static Use *op_begin(User* U) {
 104     return U->OperandList;
 105   }
 106   static Use *op_end(User* U) {
 107     return U->OperandList + U->getNumOperands();
 108   }
 109   static unsigned operands(const User *U) {
 110     return U->getNumOperands();
 111   }
 112   static inline void *allocate(unsigned); // FIXME
 113 };
 114
 115 /// Macro for generating in-class operand accessor declarations.
 116 /// It should only be called in the public section of the interface.
 117 ///
 118 #define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS) \
 119   public: \
 120   inline VALUECLASS *getOperand(unsigned) const; \
 121   inline void setOperand(unsigned, VALUECLASS*); \
 122   inline op_iterator op_begin(); \
 123   inline const_op_iterator op_begin() const; \
 124   inline op_iterator op_end(); \
 125   inline const_op_iterator op_end() const; \
 126   protected: \
 127   template <unsigned> inline Use &Op(); \
 128   template <unsigned> inline const Use &Op() const; \
 129   public: \
 130   inline unsigned getNumOperands() const
 131
 132 /// Macro for generating out-of-class operand accessor definitions
 133 #define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS) \
 134 CLASS::op_iterator CLASS::op_begin() { \
 135   return OperandTraits<CLASS>::op_begin(this); \
 136 } \
 137 CLASS::const_op_iterator CLASS::op_begin() const { \
 138   return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \
 139 } \
 140 CLASS::op_iterator CLASS::op_end() { \
 141   return OperandTraits<CLASS>::op_end(this); \
 142 } \
 143 CLASS::const_op_iterator CLASS::op_end() const { \
 144   return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \
 145 } \
 146 VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \
 147   assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
 148          && "getOperand() out of range!"); \
 149   return static_cast<VALUECLASS*>( \
 150     OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture]); \
 151 } \
 152 void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \
 153   assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
 154          && "setOperand() out of range!"); \
 155   OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \
 156 } \
 157 unsigned CLASS::getNumOperands() const { \
 158   return OperandTraits<CLASS>::operands(this);  \
 159 } \
 160 template <unsigned Idx_nocapture> Use &CLASS::Op() { \
 161   return OperandTraits<CLASS>::op_begin(this)[Idx_nocapture]; \
 162 } \
 163 template <unsigned Idx_nocapture> const Use &CLASS::Op() const { \
 164   return OperandTraits<CLASS>::op_begin( \
 165     const_cast<CLASS*>(this))[Idx_nocapture]; \
 166 }
 167
 168
 169 /// Macro for generating out-of-class operand accessor
 170 /// definitions with casted result
 171 #define DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(CLASS, VALUECLASS) \
 172 CLASS::op_iterator CLASS::op_begin() { \
 173   return OperandTraits<CLASS>::op_begin(this); \
 174 } \
 175 CLASS::const_op_iterator CLASS::op_begin() const { \
 176   return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \
 177 } \
 178 CLASS::op_iterator CLASS::op_end() { \
 179   return OperandTraits<CLASS>::op_end(this); \
 180 } \
 181 CLASS::const_op_iterator CLASS::op_end() const { \
 182   return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \
 183 } \
 184 VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \
 185   assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
 186          && "getOperand() out of range!"); \
 187   return cast<VALUECLASS>( \
 188     OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture]); \
 189 } \
 190 void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \
 191   assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
 192          && "setOperand() out of range!"); \
 193   OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \
 194 } \
 195 unsigned CLASS::getNumOperands() const { \
 196   return OperandTraits<CLASS>::operands(this); \
 197 } \
 198 template <unsigned Idx_nocapture> Use &CLASS::Op() { \
 199   return OperandTraits<CLASS>::op_begin(this)[Idx_nocapture]; \
 200 } \
 201 template <unsigned Idx_nocapture> const Use &CLASS::Op() const { \
 202   return OperandTraits<CLASS>::op_begin( \
 203     const_cast<CLASS*>(this))[Idx_nocapture]; \
 204 }
 205
 206
 207 } // End llvm namespace
 208
 209 #endif