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
|
//===-- 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:
/// 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 the parameter. The result
/// is the index of the parameter.
/// @brief Get a parameter index
uint16_t getParamIndex(unsigned attr_index) const {
return attrs[attr_index].index;
}
/// 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;
}
/// 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.
/// @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(); }
/// @returns true if this ParamAttrsList is empty.
/// @brief Determine emptiness of ParamAttrsList.
unsigned empty() const { return attrs.empty(); }
/// 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;
}
/// @}
/// @name Mutators
/// @{
public:
/// This adds a pair to the list of parameter index and attribute pairs
/// represented by this class. If the parameter index already exists then
/// its attributes are overwritten. Otherwise it is added to the list.
/// @brief Insert ParameterAttributes for an index
void setAttributes(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
|
