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 // FixedNumOperand 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 { op_beginFixedNumOperandTraits32 static Use *op_begin(User* U) { 33 return reinterpret_cast<Use*>(U) - ARITY; 34 } op_endFixedNumOperandTraits35 static Use *op_end(User* U) { 36 return reinterpret_cast<Use*>(U); 37 } operandsFixedNumOperandTraits38 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 : public prefix, public U { 48 overlay(); // DO NOT IMPLEMENT 49 }; 50 }; 51 }; 52 53 //===----------------------------------------------------------------------===// 54 // OptionalOperand Trait Class 55 //===----------------------------------------------------------------------===// 56 57 /// OptionalOperandTraits - when the number of operands may change at runtime. 58 /// Naturally it may only decrease, because the allocations may not change. 59 60 template <unsigned ARITY = 1> 61 struct OptionalOperandTraits : public FixedNumOperandTraits<ARITY> { operandsOptionalOperandTraits62 static unsigned operands(const User *U) { 63 return U->getNumOperands(); 64 } 65 }; 66 67 //===----------------------------------------------------------------------===// 68 // VariadicOperand Trait Class 69 //===----------------------------------------------------------------------===// 70 71 /// VariadicOperandTraits - determine the allocation regime of the Use array 72 /// when it is a prefix to the User object, and the number of Use objects is 73 /// only known at allocation time. 74 75 template <unsigned MINARITY = 0> 76 struct VariadicOperandTraits { op_beginVariadicOperandTraits77 static Use *op_begin(User* U) { 78 return reinterpret_cast<Use*>(U) - U->getNumOperands(); 79 } op_endVariadicOperandTraits80 static Use *op_end(User* U) { 81 return reinterpret_cast<Use*>(U); 82 } operandsVariadicOperandTraits83 static unsigned operands(const User *U) { 84 return U->getNumOperands(); 85 } 86 }; 87 88 //===----------------------------------------------------------------------===// 89 // HungoffOperand Trait Class 90 //===----------------------------------------------------------------------===// 91 92 /// HungoffOperandTraits - determine the allocation regime of the Use array 93 /// when it is not a prefix to the User object, but allocated at an unrelated 94 /// heap address. 95 /// Assumes that the User subclass that is determined by this traits class 96 /// has an OperandList member of type User::op_iterator. [Note: this is now 97 /// trivially satisfied, because User has that member for historic reasons.] 98 /// 99 /// This is the traits class that is needed when the Use array must be 100 /// resizable. 101 102 template <unsigned MINARITY = 1> 103 struct HungoffOperandTraits { op_beginHungoffOperandTraits104 static Use *op_begin(User* U) { 105 return U->OperandList; 106 } op_endHungoffOperandTraits107 static Use *op_end(User* U) { 108 return U->OperandList + U->getNumOperands(); 109 } operandsHungoffOperandTraits110 static unsigned operands(const User *U) { 111 return U->getNumOperands(); 112 } 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 <int> inline Use &Op(); \ 128 template <int> 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 <int Idx_nocapture> Use &CLASS::Op() { \ 161 return this->OpFrom<Idx_nocapture>(this); \ 162 } \ 163 template <int Idx_nocapture> const Use &CLASS::Op() const { \ 164 return this->OpFrom<Idx_nocapture>(this); \ 165 } 166 167 168 /// Macro for generating out-of-class operand accessor 169 /// definitions with casted result 170 #define DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(CLASS, VALUECLASS) \ 171 CLASS::op_iterator CLASS::op_begin() { \ 172 return OperandTraits<CLASS>::op_begin(this); \ 173 } \ 174 CLASS::const_op_iterator CLASS::op_begin() const { \ 175 return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \ 176 } \ 177 CLASS::op_iterator CLASS::op_end() { \ 178 return OperandTraits<CLASS>::op_end(this); \ 179 } \ 180 CLASS::const_op_iterator CLASS::op_end() const { \ 181 return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \ 182 } \ 183 VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \ 184 assert(i_nocapture < OperandTraits<CLASS>::operands(this) \ 185 && "getOperand() out of range!"); \ 186 return cast<VALUECLASS>( \ 187 OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture]); \ 188 } \ 189 void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \ 190 assert(i_nocapture < OperandTraits<CLASS>::operands(this) \ 191 && "setOperand() out of range!"); \ 192 OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \ 193 } \ 194 unsigned CLASS::getNumOperands() const { \ 195 return OperandTraits<CLASS>::operands(this); \ 196 } \ 197 template <int Idx_nocapture> Use &CLASS::Op() { \ 198 return this->OpFrom<Idx_nocapture>(this); \ 199 } \ 200 template <int Idx_nocapture> const Use &CLASS::Op() const { \ 201 return this->OpFrom<Idx_nocapture>(this); \ 202 } 203 204 205 } // End llvm namespace 206 207 #endif 208