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
19namespace 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
29template <typename SubClass, unsigned ARITY>
30struct 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
52template <typename SubClass, unsigned ARITY = 1>
53struct 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
67template <typename SubClass, unsigned MINARITY = 0>
68struct 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
94template <unsigned MINARITY = 1>
95struct 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) \
126CLASS::op_iterator CLASS::op_begin() { \
127 return OperandTraits<CLASS>::op_begin(this); \
128} \
129CLASS::const_op_iterator CLASS::op_begin() const { \
130 return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \
131} \
132CLASS::op_iterator CLASS::op_end() { \
133 return OperandTraits<CLASS>::op_end(this); \
134} \
135CLASS::const_op_iterator CLASS::op_end() const { \
136 return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \
137} \
138VALUECLASS *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} \
144void 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} \
149unsigned CLASS::getNumOperands() const { \
150 return OperandTraits<CLASS>::operands(this); \
151} \
152template <int Idx_nocapture> Use &CLASS::Op() { \
153 return this->OpFrom<Idx_nocapture>(this); \
154} \
155template <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