Remove redundant 'llvm::' qualifications
[oota-llvm.git] / include / llvm / Attributes.h
1 //===-- llvm/Attributes.h - Container for Attributes ------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// \brief This file contains the simple types necessary to represent the
12 /// attributes associated with functions and their calls.
13 ///
14 //===----------------------------------------------------------------------===//
15
16 #ifndef LLVM_ATTRIBUTES_H
17 #define LLVM_ATTRIBUTES_H
18
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/Support/MathExtras.h"
21 #include <cassert>
22 #include <string>
23
24 namespace llvm {
25
26 class AttrBuilder;
27 class AttributeImpl;
28 class LLVMContext;
29 class Type;
30
31 //===----------------------------------------------------------------------===//
32 /// \class
33 /// \brief Functions, function parameters, and return types can have attributes
34 /// to indicate how they should be treated by optimizations and code
35 /// generation. This class represents one of those attributes. It's light-weight
36 /// and should be passed around by-value.
37 class Attribute {
38 public:
39   /// This enumeration lists the attributes that can be associated with
40   /// parameters, function results or the function itself.
41   ///
42   /// Note: uwtable is about the ABI or the user mandating an entry in the
43   /// unwind table. The nounwind attribute is about an exception passing by the
44   /// function.
45   ///
46   /// In a theoretical system that uses tables for profiling and sjlj for
47   /// exceptions, they would be fully independent. In a normal system that uses
48   /// tables for both, the semantics are:
49   ///
50   /// nil                = Needs an entry because an exception might pass by.
51   /// nounwind           = No need for an entry
52   /// uwtable            = Needs an entry because the ABI says so and because
53   ///                      an exception might pass by.
54   /// uwtable + nounwind = Needs an entry because the ABI says so.
55
56   enum AttrKind {
57     // IR-Level Attributes
58     None,                  ///< No attributes have been set
59     AddressSafety,         ///< Address safety checking is on.
60     Alignment,             ///< Alignment of parameter (5 bits)
61                            ///< stored as log2 of alignment with +1 bias
62                            ///< 0 means unaligned (different from align(1))
63     AlwaysInline,          ///< inline=always
64     ByVal,                 ///< Pass structure by value
65     InlineHint,            ///< Source said inlining was desirable
66     InReg,                 ///< Force argument to be passed in register
67     MinSize,               ///< Function must be optimized for size first
68     Naked,                 ///< Naked function
69     Nest,                  ///< Nested function static chain
70     NoAlias,               ///< Considered to not alias after call
71     NoCapture,             ///< Function creates no aliases of pointer
72     NoDuplicate,           ///< Call cannot be duplicated
73     NoImplicitFloat,       ///< Disable implicit floating point insts
74     NoInline,              ///< inline=never
75     NonLazyBind,           ///< Function is called early and/or
76                            ///< often, so lazy binding isn't worthwhile
77     NoRedZone,             ///< Disable redzone
78     NoReturn,              ///< Mark the function as not returning
79     NoUnwind,              ///< Function doesn't unwind stack
80     OptimizeForSize,       ///< opt_size
81     ReadNone,              ///< Function does not access memory
82     ReadOnly,              ///< Function only reads from memory
83     ReturnsTwice,          ///< Function can return twice
84     SExt,                  ///< Sign extended before/after call
85     StackAlignment,        ///< Alignment of stack for function (3 bits)
86                            ///< stored as log2 of alignment with +1 bias 0
87                            ///< means unaligned (different from
88                            ///< alignstack=(1))
89     StackProtect,          ///< Stack protection.
90     StackProtectReq,       ///< Stack protection required.
91     StructRet,             ///< Hidden pointer to structure to return
92     UWTable,               ///< Function must be in a unwind table
93     ZExt                   ///< Zero extended before/after call
94   };
95 private:
96   AttributeImpl *pImpl;
97   Attribute(AttributeImpl *A) : pImpl(A) {}
98 public:
99   Attribute() : pImpl(0) {}
100
101   /// \brief Return a uniquified Attribute object. This takes the uniquified
102   /// value from the Builder and wraps it in the Attribute class.
103   static Attribute get(LLVMContext &Context, ArrayRef<AttrKind> Vals);
104   static Attribute get(LLVMContext &Context, AttrBuilder &B);
105
106   /// \brief Return true if the attribute is present.
107   bool hasAttribute(AttrKind Val) const;
108
109   /// \brief Return true if attributes exist
110   bool hasAttributes() const;
111
112   /// \brief Return true if the attributes are a non-null intersection.
113   bool hasAttributes(const Attribute &A) const;
114
115   /// \brief Returns the alignment field of an attribute as a byte alignment
116   /// value.
117   unsigned getAlignment() const;
118
119   /// \brief Returns the stack alignment field of an attribute as a byte
120   /// alignment value.
121   unsigned getStackAlignment() const;
122
123   bool operator==(AttrKind K) const;
124   bool operator!=(AttrKind K) const;
125
126   // FIXME: Remove these 'operator' methods.
127   bool operator==(const Attribute &A) const {
128     return pImpl == A.pImpl;
129   }
130   bool operator!=(const Attribute &A) const {
131     return pImpl != A.pImpl;
132   }
133
134   uint64_t getBitMask() const;
135
136   /// \brief Which attributes cannot be applied to a type.
137   static Attribute typeIncompatible(Type *Ty);
138
139   /// \brief This returns an integer containing an encoding of all the LLVM
140   /// attributes found in the given attribute bitset.  Any change to this
141   /// encoding is a breaking change to bitcode compatibility.
142   static uint64_t encodeLLVMAttributesForBitcode(Attribute Attrs);
143
144   /// \brief This returns an attribute bitset containing the LLVM attributes
145   /// that have been decoded from the given integer.  This function must stay in
146   /// sync with 'encodeLLVMAttributesForBitcode'.
147   static Attribute decodeLLVMAttributesForBitcode(LLVMContext &C,
148                                                   uint64_t EncodedAttrs);
149
150   /// \brief The Attribute is converted to a string of equivalent mnemonic. This
151   /// is, presumably, for writing out the mnemonics for the assembly writer.
152   std::string getAsString() const;
153 };
154
155 //===----------------------------------------------------------------------===//
156 /// \class
157 /// \brief This class is used in conjunction with the Attribute::get method to
158 /// create an Attribute object. The object itself is uniquified. The Builder's
159 /// value, however, is not. So this can be used as a quick way to test for
160 /// equality, presence of attributes, etc.
161 class AttrBuilder {
162   uint64_t Bits;
163 public:
164   AttrBuilder() : Bits(0) {}
165   explicit AttrBuilder(uint64_t B) : Bits(B) {}
166   AttrBuilder(const Attribute &A) : Bits(A.getBitMask()) {}
167
168   void clear() { Bits = 0; }
169
170   /// addAttribute - Add an attribute to the builder.
171   AttrBuilder &addAttribute(Attribute::AttrKind Val);
172
173   /// removeAttribute - Remove an attribute from the builder.
174   AttrBuilder &removeAttribute(Attribute::AttrKind Val);
175
176   /// addAttribute - Add the attributes from A to the builder.
177   AttrBuilder &addAttributes(const Attribute &A);
178
179   /// removeAttribute - Remove the attributes from A from the builder.
180   AttrBuilder &removeAttributes(const Attribute &A);
181
182   /// \brief Return true if the builder has the specified attribute.
183   bool contains(Attribute::AttrKind A) const;
184
185   /// hasAttributes - Return true if the builder has IR-level attributes.
186   bool hasAttributes() const;
187
188   /// hasAttributes - Return true if the builder has any attribute that's in the
189   /// specified attribute.
190   bool hasAttributes(const Attribute &A) const;
191
192   /// hasAlignmentAttr - Return true if the builder has an alignment attribute.
193   bool hasAlignmentAttr() const;
194
195   /// getAlignment - Retrieve the alignment attribute, if it exists.
196   uint64_t getAlignment() const;
197
198   /// getStackAlignment - Retrieve the stack alignment attribute, if it exists.
199   uint64_t getStackAlignment() const;
200
201   /// addAlignmentAttr - This turns an int alignment (which must be a power of
202   /// 2) into the form used internally in Attribute.
203   AttrBuilder &addAlignmentAttr(unsigned Align);
204
205   /// addStackAlignmentAttr - This turns an int stack alignment (which must be a
206   /// power of 2) into the form used internally in Attribute.
207   AttrBuilder &addStackAlignmentAttr(unsigned Align);
208
209   /// addRawValue - Add the raw value to the internal representation.
210   /// N.B. This should be used ONLY for decoding LLVM bitcode!
211   AttrBuilder &addRawValue(uint64_t Val);
212
213   /// @brief Remove attributes that are used on functions only.
214   void removeFunctionOnlyAttrs() {
215     removeAttribute(Attribute::NoReturn)
216       .removeAttribute(Attribute::NoUnwind)
217       .removeAttribute(Attribute::ReadNone)
218       .removeAttribute(Attribute::ReadOnly)
219       .removeAttribute(Attribute::NoInline)
220       .removeAttribute(Attribute::AlwaysInline)
221       .removeAttribute(Attribute::OptimizeForSize)
222       .removeAttribute(Attribute::StackProtect)
223       .removeAttribute(Attribute::StackProtectReq)
224       .removeAttribute(Attribute::NoRedZone)
225       .removeAttribute(Attribute::NoImplicitFloat)
226       .removeAttribute(Attribute::Naked)
227       .removeAttribute(Attribute::InlineHint)
228       .removeAttribute(Attribute::StackAlignment)
229       .removeAttribute(Attribute::UWTable)
230       .removeAttribute(Attribute::NonLazyBind)
231       .removeAttribute(Attribute::ReturnsTwice)
232       .removeAttribute(Attribute::AddressSafety)
233       .removeAttribute(Attribute::MinSize)
234       .removeAttribute(Attribute::NoDuplicate);
235   }
236
237   uint64_t getBitMask() const { return Bits; }
238
239   bool operator==(const AttrBuilder &B) {
240     return Bits == B.Bits;
241   }
242   bool operator!=(const AttrBuilder &B) {
243     return Bits != B.Bits;
244   }
245 };
246
247 //===----------------------------------------------------------------------===//
248 /// \class
249 /// \brief This is just a pair of values to associate a set of attributes with
250 /// an index.
251 struct AttributeWithIndex {
252   Attribute Attrs;  ///< The attributes that are set, or'd together.
253   unsigned Index;   ///< Index of the parameter for which the attributes apply.
254                     ///< Index 0 is used for return value attributes.
255                     ///< Index ~0U is used for function attributes.
256
257   static AttributeWithIndex get(LLVMContext &C, unsigned Idx,
258                                 ArrayRef<Attribute::AttrKind> Attrs) {
259     return get(Idx, Attribute::get(C, Attrs));
260   }
261   static AttributeWithIndex get(unsigned Idx, Attribute Attrs) {
262     AttributeWithIndex P;
263     P.Index = Idx;
264     P.Attrs = Attrs;
265     return P;
266   }
267 };
268
269 //===----------------------------------------------------------------------===//
270 // AttributeSet Smart Pointer
271 //===----------------------------------------------------------------------===//
272
273 class AttributeSetImpl;
274
275 //===----------------------------------------------------------------------===//
276 /// \class
277 /// \brief This class manages the ref count for the opaque AttributeSetImpl
278 /// object and provides accessors for it.
279 class AttributeSet {
280 public:
281   enum AttrIndex {
282     ReturnIndex = 0U,
283     FunctionIndex = ~0U
284   };
285 private:
286   /// \brief The attributes that we are managing.  This can be null to represent
287   /// the empty attributes list.
288   AttributeSetImpl *AttrList;
289
290   /// \brief The attributes for the specified index are returned.  Attributes
291   /// for the result are denoted with Idx = 0.
292   Attribute getAttributes(unsigned Idx) const;
293
294   explicit AttributeSet(AttributeSetImpl *LI) : AttrList(LI) {}
295 public:
296   AttributeSet() : AttrList(0) {}
297   AttributeSet(const AttributeSet &P) : AttrList(P.AttrList) {}
298   const AttributeSet &operator=(const AttributeSet &RHS);
299
300   //===--------------------------------------------------------------------===//
301   // Attribute List Construction and Mutation
302   //===--------------------------------------------------------------------===//
303
304   /// \brief Return an AttributeSet with the specified parameters in it.
305   static AttributeSet get(LLVMContext &C, ArrayRef<AttributeWithIndex> Attrs);
306
307   /// \brief Add the specified attribute at the specified index to this
308   /// attribute list.  Since attribute lists are immutable, this returns the new
309   /// list.
310   AttributeSet addAttr(LLVMContext &C, unsigned Idx, Attribute Attrs) const;
311
312   /// \brief Remove the specified attribute at the specified index from this
313   /// attribute list.  Since attribute lists are immutable, this returns the new
314   /// list.
315   AttributeSet removeAttr(LLVMContext &C, unsigned Idx, Attribute Attrs) const;
316
317   //===--------------------------------------------------------------------===//
318   // Attribute Set Accessors
319   //===--------------------------------------------------------------------===//
320
321   /// \brief The attributes for the specified index are returned.
322   Attribute getParamAttributes(unsigned Idx) const {
323     return getAttributes(Idx);
324   }
325
326   /// \brief The attributes for the ret value are returned.
327   Attribute getRetAttributes() const {
328     return getAttributes(ReturnIndex);
329   }
330
331   /// \brief The function attributes are returned.
332   Attribute getFnAttributes() const {
333     return getAttributes(FunctionIndex);
334   }
335
336   /// \brief Return the alignment for the specified function parameter.
337   unsigned getParamAlignment(unsigned Idx) const {
338     return getAttributes(Idx).getAlignment();
339   }
340
341   /// \brief Return true if the attribute exists at the given index.
342   bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
343
344   /// \brief Return true if attribute exists at the given index.
345   bool hasAttributes(unsigned Index) const;
346
347   /// \brief Get the stack alignment.
348   unsigned getStackAlignment(unsigned Index) const;
349
350   /// \brief Return the attributes at the index as a string.
351   std::string getAsString(unsigned Index) const;
352
353   uint64_t getBitMask(unsigned Index) const;
354
355   /// \brief Return true if the specified attribute is set for at least one
356   /// parameter or for the return value.
357   bool hasAttrSomewhere(Attribute::AttrKind Attr) const;
358
359   /// operator==/!= - Provide equality predicates.
360   bool operator==(const AttributeSet &RHS) const {
361     return AttrList == RHS.AttrList;
362   }
363   bool operator!=(const AttributeSet &RHS) const {
364     return AttrList != RHS.AttrList;
365   }
366
367   //===--------------------------------------------------------------------===//
368   // Attribute Set Introspection
369   //===--------------------------------------------------------------------===//
370
371   /// \brief Return a raw pointer that uniquely identifies this attribute list.
372   void *getRawPointer() const {
373     return AttrList;
374   }
375
376   // Attributes are stored as a dense set of slots, where there is one slot for
377   // each argument that has an attribute.  This allows walking over the dense
378   // set instead of walking the sparse list of attributes.
379
380   /// \brief Return true if there are no attributes.
381   bool isEmpty() const {
382     return AttrList == 0;
383   }
384
385   /// \brief Return the number of slots used in this attribute list.  This is
386   /// the number of arguments that have an attribute set on them (including the
387   /// function itself).
388   unsigned getNumSlots() const;
389
390   /// \brief Return the AttributeWithIndex at the specified slot.  This holds a
391   /// index number plus a set of attributes.
392   const AttributeWithIndex &getSlot(unsigned Slot) const;
393
394   void dump() const;
395 };
396
397 } // end llvm namespace
398
399 #endif