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_IR_OPERANDTRAITS_H 16 #define LLVM_IR_OPERANDTRAITS_H 17 18 #include "llvm/IR/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 <typename SubClass, unsigned ARITY> 31 struct FixedNumOperandTraits { 32 static Use *op_begin(SubClass* U) { 33 static_assert( 34 !std::is_polymorphic<SubClass>::value, 35 "adding virtual methods to subclasses of User breaks use lists"); 36 return reinterpret_cast<Use*>(U) - ARITY; 37 } 38 static Use *op_end(SubClass* U) { 39 return reinterpret_cast<Use*>(U); 40 } 41 static unsigned operands(const User*) { 42 return ARITY; 43 } 44 }; 45 46 //===----------------------------------------------------------------------===// 47 // OptionalOperand Trait Class 48 //===----------------------------------------------------------------------===// 49 50 /// OptionalOperandTraits - when the number of operands may change at runtime. 51 /// Naturally it may only decrease, because the allocations may not change. 52 53 template <typename SubClass, unsigned ARITY = 1> 54 struct OptionalOperandTraits : public FixedNumOperandTraits<SubClass, ARITY> { 55 static unsigned operands(const User *U) { 56 return U->getNumOperands(); 57 } 58 }; 59 60 //===----------------------------------------------------------------------===// 61 // VariadicOperand Trait Class 62 //===----------------------------------------------------------------------===// 63 64 /// VariadicOperandTraits - determine the allocation regime of the Use array 65 /// when it is a prefix to the User object, and the number of Use objects is 66 /// only known at allocation time. 67 68 template <typename SubClass, unsigned MINARITY = 0> 69 struct VariadicOperandTraits { 70 static Use *op_begin(SubClass* U) { 71 static_assert( 72 !std::is_polymorphic<SubClass>::value, 73 "adding virtual methods to subclasses of User breaks use lists"); 74 return reinterpret_cast<Use*>(U) - static_cast<User*>(U)->getNumOperands(); 75 } 76 static Use *op_end(SubClass* U) { 77 return reinterpret_cast<Use*>(U); 78 } 79 static unsigned operands(const User *U) { 80 return U->getNumOperands(); 81 } 82 }; 83 84 //===----------------------------------------------------------------------===// 85 // HungoffOperand Trait Class 86 //===----------------------------------------------------------------------===// 87 88 /// HungoffOperandTraits - determine the allocation regime of the Use array 89 /// when it is not a prefix to the User object, but allocated at an unrelated 90 /// heap address. 91 /// 92 /// This is the traits class that is needed when the Use array must be 93 /// resizable. 94 95 template <unsigned MINARITY = 1> 96 struct HungoffOperandTraits { 97 static Use *op_begin(User* U) { 98 return U->getOperandList(); 99 } 100 static Use *op_end(User* U) { 101 return U->getOperandList() + U->getNumOperands(); 102 } 103 static unsigned operands(const User *U) { 104 return U->getNumOperands(); 105 } 106 }; 107 108 /// Macro for generating in-class operand accessor declarations. 109 /// It should only be called in the public section of the interface. 110 /// 111 #define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS) \ 112 public: \ 113 inline VALUECLASS *getOperand(unsigned) const; \ 114 inline void setOperand(unsigned, VALUECLASS*); \ 115 inline op_iterator op_begin(); \ 116 inline const_op_iterator op_begin() const; \ 117 inline op_iterator op_end(); \ 118 inline const_op_iterator op_end() const; \ 119 protected: \ 120 template <int> inline Use &Op(); \ 121 template <int> inline const Use &Op() const; \ 122 public: \ 123 inline unsigned getNumOperands() const 124 125 /// Macro for generating out-of-class operand accessor definitions 126 #define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS) \ 127 CLASS::op_iterator CLASS::op_begin() { \ 128 return OperandTraits<CLASS>::op_begin(this); \ 129 } \ 130 CLASS::const_op_iterator CLASS::op_begin() const { \ 131 return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \ 132 } \ 133 CLASS::op_iterator CLASS::op_end() { \ 134 return OperandTraits<CLASS>::op_end(this); \ 135 } \ 136 CLASS::const_op_iterator CLASS::op_end() const { \ 137 return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \ 138 } \ 139 VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \ 140 assert(i_nocapture < OperandTraits<CLASS>::operands(this) \ 141 && "getOperand() out of range!"); \ 142 return cast_or_null<VALUECLASS>( \ 143 OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture].get()); \ 144 } \ 145 void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \ 146 assert(i_nocapture < OperandTraits<CLASS>::operands(this) \ 147 && "setOperand() out of range!"); \ 148 OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \ 149 } \ 150 unsigned CLASS::getNumOperands() const { \ 151 return OperandTraits<CLASS>::operands(this); \ 152 } \ 153 template <int Idx_nocapture> Use &CLASS::Op() { \ 154 return this->OpFrom<Idx_nocapture>(this); \ 155 } \ 156 template <int Idx_nocapture> const Use &CLASS::Op() const { \ 157 return this->OpFrom<Idx_nocapture>(this); \ 158 } 159 160 161 } // End llvm namespace 162 163 #endif 164
