1 //===-- llvm/OperandTraits.h - OperandTraits class definition ---*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
15 #ifndef LLVM_OPERAND_TRAITS_H
16 #define LLVM_OPERAND_TRAITS_H
18 #include "llvm/User.h"
22 //===----------------------------------------------------------------------===//
23 // FixedNumOperands Trait Class
24 //===----------------------------------------------------------------------===//
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.
30 template <unsigned ARITY>
31 struct FixedNumOperandTraits {
32 static Use *op_begin(User* U) {
33 return reinterpret_cast<Use*>(U) - ARITY;
35 static Use *op_end(User* U) {
36 return reinterpret_cast<Use*>(U);
38 static unsigned operands(const User*) {
43 prefix(); // DO NOT IMPLEMENT
47 struct overlay : public prefix, public U {
48 overlay(); // DO NOT IMPLEMENT
53 //===----------------------------------------------------------------------===//
54 // OptionalOperands Trait Class
55 //===----------------------------------------------------------------------===//
57 template <unsigned ARITY = 1>
58 struct OptionalOperandTraits : public FixedNumOperandTraits<ARITY> {
59 static unsigned operands(const User *U) {
60 return U->getNumOperands();
64 //===----------------------------------------------------------------------===//
65 // VariadicOperand Trait Class
66 //===----------------------------------------------------------------------===//
68 /// VariadicOperandTraits - determine the allocation regime of the Use array
69 /// when it is a prefix to the User object, and the number of Use objects is
70 /// only known at allocation time.
72 template <unsigned MINARITY = 0>
73 struct VariadicOperandTraits {
74 static Use *op_begin(User* U) {
75 return reinterpret_cast<Use*>(U) - U->getNumOperands();
77 static Use *op_end(User* U) {
78 return reinterpret_cast<Use*>(U);
80 static unsigned operands(const User *U) {
81 return U->getNumOperands();
85 //===----------------------------------------------------------------------===//
86 // HungoffOperand Trait Class
87 //===----------------------------------------------------------------------===//
89 /// HungoffOperandTraits - determine the allocation regime of the Use array
90 /// when it is not a prefix to the User object, but allocated at an unrelated
92 /// Assumes that the User subclass that is determined by this traits class
93 /// has an OperandList member of type User::op_iterator. [Note: this is now
94 /// trivially satisfied, because User has that member for historic reasons.]
96 /// This is the traits class that is needed when the Use array must be
99 template <unsigned MINARITY = 1>
100 struct HungoffOperandTraits {
101 static Use *op_begin(User* U) {
102 return U->OperandList;
104 static Use *op_end(User* U) {
105 return U->OperandList + U->getNumOperands();
107 static unsigned operands(const User *U) {
108 return U->getNumOperands();
112 /// Macro for generating in-class operand accessor declarations.
113 /// It should only be called in the public section of the interface.
115 #define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS) \
117 inline VALUECLASS *getOperand(unsigned) const; \
118 inline void setOperand(unsigned, VALUECLASS*); \
119 inline op_iterator op_begin(); \
120 inline const_op_iterator op_begin() const; \
121 inline op_iterator op_end(); \
122 inline const_op_iterator op_end() const; \
124 template <int> inline Use &Op(); \
125 template <int> inline const Use &Op() const; \
127 inline unsigned getNumOperands() const
129 /// Macro for generating out-of-class operand accessor definitions
130 #define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS) \
131 CLASS::op_iterator CLASS::op_begin() { \
132 return OperandTraits<CLASS>::op_begin(this); \
134 CLASS::const_op_iterator CLASS::op_begin() const { \
135 return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \
137 CLASS::op_iterator CLASS::op_end() { \
138 return OperandTraits<CLASS>::op_end(this); \
140 CLASS::const_op_iterator CLASS::op_end() const { \
141 return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \
143 VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \
144 assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
145 && "getOperand() out of range!"); \
146 return static_cast<VALUECLASS*>( \
147 OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture]); \
149 void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \
150 assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
151 && "setOperand() out of range!"); \
152 OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \
154 unsigned CLASS::getNumOperands() const { \
155 return OperandTraits<CLASS>::operands(this); \
157 template <int Idx_nocapture> Use &CLASS::Op() { \
158 return this->OpFrom<Idx_nocapture>(this); \
160 template <int Idx_nocapture> const Use &CLASS::Op() const { \
161 return this->OpFrom<Idx_nocapture>(this); \
165 /// Macro for generating out-of-class operand accessor
166 /// definitions with casted result
167 #define DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(CLASS, VALUECLASS) \
168 CLASS::op_iterator CLASS::op_begin() { \
169 return OperandTraits<CLASS>::op_begin(this); \
171 CLASS::const_op_iterator CLASS::op_begin() const { \
172 return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \
174 CLASS::op_iterator CLASS::op_end() { \
175 return OperandTraits<CLASS>::op_end(this); \
177 CLASS::const_op_iterator CLASS::op_end() const { \
178 return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \
180 VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \
181 assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
182 && "getOperand() out of range!"); \
183 return cast<VALUECLASS>( \
184 OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture]); \
186 void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \
187 assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
188 && "setOperand() out of range!"); \
189 OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \
191 unsigned CLASS::getNumOperands() const { \
192 return OperandTraits<CLASS>::operands(this); \
194 template <int Idx_nocapture> Use &CLASS::Op() { \
195 return this->OpFrom<Idx_nocapture>(this); \
197 template <int Idx_nocapture> const Use &CLASS::Op() const { \
198 return this->OpFrom<Idx_nocapture>(this); \
202 } // End llvm namespace