LLVM  9.0.0svn
OperandTraits.h
Go to the documentation of this file.
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>
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>
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>
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
static Use * op_end(SubClass *U)
Definition: OperandTraits.h:75
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static Use * op_end(User *U)
Definition: OperandTraits.h:99
A Use represents the edge between a Value definition and its users.
Definition: Use.h:55
static unsigned operands(const User *U)
const Use * getOperandList() const
Definition: User.h:162
static unsigned operands(const User *U)
Definition: OperandTraits.h:78
static Use * op_end(SubClass *U)
Definition: OperandTraits.h:37
static unsigned operands(const User *U)
Definition: OperandTraits.h:54
OptionalOperandTraits - when the number of operands may change at runtime.
Definition: OperandTraits.h:53
unsigned getNumOperands() const
Definition: User.h:191
static Use * op_begin(SubClass *U)
Definition: OperandTraits.h:69
static Use * op_begin(SubClass *U)
Definition: OperandTraits.h:31
static unsigned operands(const User *)
Definition: OperandTraits.h:40
HungoffOperandTraits - determine the allocation regime of the Use array when it is not a prefix to th...
Definition: OperandTraits.h:95
FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:30
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:68
static Use * op_begin(User *U)
Definition: OperandTraits.h:96