1 //===-- llvm/OperandTraits.h - OperandTraits class definition ---*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the traits classes that are handy for enforcing the correct
10 // layout of various User subclasses. It also provides the means for accessing
11 // the operands in the most efficient manner.
12 //
13 
14 #ifndef LLVM_IR_OPERANDTRAITS_H
15 #define LLVM_IR_OPERANDTRAITS_H
16 
17 #include "llvm/IR/User.h"
18 
19 namespace llvm {
20 
21 //===----------------------------------------------------------------------===//
22 //                          FixedNumOperand Trait Class
23 //===----------------------------------------------------------------------===//
24 
25 /// FixedNumOperandTraits - determine the allocation regime of the Use array
26 /// when it is a prefix to the User object, and the number of Use objects is
27 /// known at compile time.
28 
29 template <typename SubClass, unsigned ARITY>
30 struct FixedNumOperandTraits {
31   static Use *op_begin(SubClass* U) {
32     static_assert(
33         !std::is_polymorphic<SubClass>::value,
34         "adding virtual methods to subclasses of User breaks use lists");
35     return reinterpret_cast<Use*>(U) - ARITY;
36   }
37   static Use *op_end(SubClass* U) {
38     return reinterpret_cast<Use*>(U);
39   }
40   static unsigned operands(const User*) {
41     return ARITY;
42   }
43 };
44 
45 //===----------------------------------------------------------------------===//
46 //                          OptionalOperand Trait Class
47 //===----------------------------------------------------------------------===//
48 
49 /// OptionalOperandTraits - when the number of operands may change at runtime.
50 /// Naturally it may only decrease, because the allocations may not change.
51 
52 template <typename SubClass, unsigned ARITY = 1>
53 struct OptionalOperandTraits : public FixedNumOperandTraits<SubClass, ARITY> {
54   static unsigned operands(const User *U) {
55     return U->getNumOperands();
56   }
57 };
58 
59 //===----------------------------------------------------------------------===//
60 //                          VariadicOperand Trait Class
61 //===----------------------------------------------------------------------===//
62 
63 /// VariadicOperandTraits - determine the allocation regime of the Use array
64 /// when it is a prefix to the User object, and the number of Use objects is
65 /// only known at allocation time.
66 
67 template <typename SubClass, unsigned MINARITY = 0>
68 struct VariadicOperandTraits {
69   static Use *op_begin(SubClass* U) {
70     static_assert(
71         !std::is_polymorphic<SubClass>::value,
72         "adding virtual methods to subclasses of User breaks use lists");
73     return reinterpret_cast<Use*>(U) - static_cast<User*>(U)->getNumOperands();
74   }
75   static Use *op_end(SubClass* U) {
76     return reinterpret_cast<Use*>(U);
77   }
78   static unsigned operands(const User *U) {
79     return U->getNumOperands();
80   }
81 };
82 
83 //===----------------------------------------------------------------------===//
84 //                          HungoffOperand Trait Class
85 //===----------------------------------------------------------------------===//
86 
87 /// HungoffOperandTraits - determine the allocation regime of the Use array
88 /// when it is not a prefix to the User object, but allocated at an unrelated
89 /// heap address.
90 ///
91 /// This is the traits class that is needed when the Use array must be
92 /// resizable.
93 
94 template <unsigned MINARITY = 1>
95 struct HungoffOperandTraits {
96   static Use *op_begin(User* U) {
97     return U->getOperandList();
98   }
99   static Use *op_end(User* U) {
100     return U->getOperandList() + U->getNumOperands();
101   }
102   static unsigned operands(const User *U) {
103     return U->getNumOperands();
104   }
105 };
106 
107 /// Macro for generating in-class operand accessor declarations.
108 /// It should only be called in the public section of the interface.
109 ///
110 #define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS) \
111   public: \
112   inline VALUECLASS *getOperand(unsigned) const; \
113   inline void setOperand(unsigned, VALUECLASS*); \
114   inline op_iterator op_begin(); \
115   inline const_op_iterator op_begin() const; \
116   inline op_iterator op_end(); \
117   inline const_op_iterator op_end() const; \
118   protected: \
119   template <int> inline Use &Op(); \
120   template <int> inline const Use &Op() const; \
121   public: \
122   inline unsigned getNumOperands() const
123 
124 /// Macro for generating out-of-class operand accessor definitions
125 #define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS) \
126 CLASS::op_iterator CLASS::op_begin() { \
127   return OperandTraits<CLASS>::op_begin(this); \
128 } \
129 CLASS::const_op_iterator CLASS::op_begin() const { \
130   return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \
131 } \
132 CLASS::op_iterator CLASS::op_end() { \
133   return OperandTraits<CLASS>::op_end(this); \
134 } \
135 CLASS::const_op_iterator CLASS::op_end() const { \
136   return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \
137 } \
138 VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \
139   assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
140          && "getOperand() out of range!"); \
141   return cast_or_null<VALUECLASS>( \
142     OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture].get()); \
143 } \
144 void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \
145   assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
146          && "setOperand() out of range!"); \
147   OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \
148 } \
149 unsigned CLASS::getNumOperands() const { \
150   return OperandTraits<CLASS>::operands(this); \
151 } \
152 template <int Idx_nocapture> Use &CLASS::Op() { \
153   return this->OpFrom<Idx_nocapture>(this); \
154 } \
155 template <int Idx_nocapture> const Use &CLASS::Op() const { \
156   return this->OpFrom<Idx_nocapture>(this); \
157 }
158 
159 
160 } // End llvm namespace
161 
162 #endif
163