1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
//===-- llvm/ParameterAttributes.h - Container for Param Attrs --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the types necessary to represent the parameter attributes
// associated with functions and their calls.
//
// The implementations of these classes live in lib/VMCore/Function.cpp.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_PARAMETER_ATTRIBUTES_H
#define LLVM_PARAMETER_ATTRIBUTES_H
#include "llvm/ADT/SmallVector.h"
namespace llvm {
/// Function parameters can have attributes to indicate how they should be
/// treated by optimizations and code generation. This enumeration lists the
/// attributes that can be associated with parameters or function results.
/// @brief Function parameter attributes.
enum ParameterAttributes {
NoAttributeSet = 0, ///< No attributes have been set
ZExtAttribute = 1 << 0, ///< zero extended before/after call
SExtAttribute = 1 << 1, ///< sign extended before/after call
NoReturnAttribute = 1 << 2, ///< mark the function as not returning
InRegAttribute = 1 << 3, ///< force argument to be passed in register
StructRetAttribute = 1 << 4, ///< hidden pointer to structure to return
NoUnwindAttribute = 1 << 5 ///< Function doesn't unwind stack
};
/// This class is used by Function and CallInst to represent the set of
/// parameter attributes used. It represents a list of pairs of uint16_t, one
/// for the parameter index, and one a set of ParameterAttributes bits.
/// Parameters that have no attributes are not present in the list. The list
/// may also be empty, but this doesn't occur in practice. The list constructs
/// as empty and is filled by the insert method. The list can be turned into
/// a string of mnemonics suitable for LLVM Assembly output. Various accessors
/// are provided to obtain information about the attributes.
/// @brief A List of ParameterAttributes.
class ParamAttrsList {
/// @name Accessors
/// @{
public:
/// The parameter attributes for the \p indexth parameter are returned.
/// The 0th parameter refers to the return type of the function. Note that
/// the \p param_index is an index into the function's parameters, not an
/// index into this class's list of attributes. The result of getParamIndex
/// is always suitable input to this function.
/// @returns The all the ParameterAttributes for the \p indexth parameter
/// as a uint16_t of enumeration values OR'd together.
/// @brief Get the attributes for a parameter
uint16_t getParamAttrs(uint16_t param_index) const;
/// This checks to see if the \p ith function parameter has the parameter
/// attribute given by \p attr set.
/// @returns true if the parameter attribute is set
/// @brief Determine if a ParameterAttributes is set
bool paramHasAttr(uint16_t i, ParameterAttributes attr) const {
return getParamAttrs(i) & attr;
}
/// The set of ParameterAttributes set in Attributes is converted to a
/// string of equivalent mnemonics. This is, presumably, for writing out
/// the mnemonics for the assembly writer.
/// @brief Convert parameter attribute bits to text
static std::string getParamAttrsText(uint16_t Attributes);
/// The \p Indexth parameter attribute is converted to string.
/// @brief Get the text for the parmeter attributes for one parameter.
std::string getParamAttrsTextByIndex(uint16_t Index) const {
return getParamAttrsText(getParamAttrs(Index));
}
/// @brief Comparison operator for ParamAttrsList
bool operator < (const ParamAttrsList& that) const {
if (this->attrs.size() < that.attrs.size())
return true;
if (this->attrs.size() > that.attrs.size())
return false;
for (unsigned i = 0; i < attrs.size(); ++i) {
if (attrs[i].index < that.attrs[i].index)
return true;
if (attrs[i].index > that.attrs[i].index)
return false;
if (attrs[i].attrs < that.attrs[i].attrs)
return true;
if (attrs[i].attrs > that.attrs[i].attrs)
return false;
}
return false;
}
/// Returns the parameter index of a particular parameter attribute in this
/// list of attributes. Note that the attr_index is an index into this
/// class's list of attributes, not the index of a parameter. The result
/// is the index of the parameter. Clients generally should not use this
/// method. It is used internally by LLVM.
/// @brief Get a parameter index
uint16_t getParamIndex(unsigned attr_index) const {
return attrs[attr_index].index;
}
/// Determines how many parameter attributes are set in this ParamAttrsList.
/// This says nothing about how many parameters the function has. It also
/// says nothing about the highest parameter index that has attributes.
/// Clients generally should not use this method. It is used internally by
/// LLVM.
/// @returns the number of parameter attributes in this ParamAttrsList.
/// @brief Return the number of parameter attributes this type has.
unsigned size() const { return attrs.size(); }
/// Clients generally should not use this method. It is used internally by
/// LLVM.
/// @returns true if this ParamAttrsList is empty.
/// @brief Determine emptiness of ParamAttrsList.
unsigned empty() const { return attrs.empty(); }
/// @}
/// @name Mutators
/// @{
public:
/// This method will add the \p attr to the parameter with index
/// \p param_index. If the parameter index does not exist it will be created
/// and the \p will be the only attribute set. Otherwise, any existing
/// attributes for the specified parameter remain set and the attribute
/// given by \p attr is also set.
/// @brief Add a single ParameterAttribute
void addAttribute(uint16_t param_index, ParameterAttributes attr);
/// This method will remove the \p attr to the parameter with index
/// \p param_index. If the parameter index does not exist in the list,
/// an assertion will occur. If the specified attribute is the last
/// attribute set for the specified parameter index, the attributes for
/// that index are removed completely from the list (size is decremented).
/// Otherwise, the specified attribute is removed from the set of attributes
/// for the given index.
/// @brief Remove a single ParameterAttribute
void removeAttribute(uint16_t param_index, ParameterAttributes attr);
/// This is identical to addAttribute but permits you to set multiple
/// attributes at the same time. The \p attrs value is expected to be a
/// bitwise OR of the attributes you would like to have added.
/// @brief Insert ParameterAttributes for an index
void addAttributes(uint16_t param_index, uint16_t attrs);
/// This is identical to removeAttribute but permits you to remove multiple
/// attributes at the same time. The\p attrs value is expected to be a
/// bitwise OR of the attribute syou would like to have removed.
/// @brief Remove ParameterAttributes for an index
void removeAttributes(uint16_t param_index, uint16_t attrs);
/// @}
/// @name Data
/// @{
private:
/// This is an internal structure used to associate the ParameterAttributes
/// with a parameter index.
/// @brief ParameterAttributes with a parameter index.
struct ParamAttrsWithIndex {
uint16_t attrs; ///< The attributes that are set, |'d together
uint16_t index; ///< Index of the parameter for which the attributes apply
};
SmallVector<ParamAttrsWithIndex,2> attrs; ///< The list of attributes
/// @}
};
} // End llvm namespace
#endif
|
