• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--- Attr.h - Classes for representing expressions ----------*- 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 //  This file defines the Attr interface and subclasses.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_ATTR_H
15 #define LLVM_CLANG_AST_ATTR_H
16 
17 #include "clang/Basic/LLVM.h"
18 #include "clang/Basic/AttrKinds.h"
19 #include "clang/AST/Type.h"
20 #include "clang/Basic/SourceLocation.h"
21 #include "clang/Basic/VersionTuple.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/ADT/StringSwitch.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/Support/raw_ostream.h"
27 #include <cassert>
28 #include <cstring>
29 #include <algorithm>
30 
31 namespace clang {
32   class ASTContext;
33   class IdentifierInfo;
34   class ObjCInterfaceDecl;
35   class Expr;
36   class QualType;
37   class FunctionDecl;
38   class TypeSourceInfo;
39 }
40 
41 // Defined in ASTContext.h
42 void *operator new(size_t Bytes, const clang::ASTContext &C,
43                    size_t Alignment = 16);
44 // FIXME: Being forced to not have a default argument here due to redeclaration
45 //        rules on default arguments sucks
46 void *operator new[](size_t Bytes, const clang::ASTContext &C,
47                      size_t Alignment);
48 
49 // It is good practice to pair new/delete operators.  Also, MSVC gives many
50 // warnings if a matching delete overload is not declared, even though the
51 // throw() spec guarantees it will not be implicitly called.
52 void operator delete(void *Ptr, const clang::ASTContext &C, size_t);
53 void operator delete[](void *Ptr, const clang::ASTContext &C, size_t);
54 
55 namespace clang {
56 
57 /// Attr - This represents one attribute.
58 class Attr {
59 private:
60   SourceRange Range;
61   unsigned AttrKind : 16;
62 
63 protected:
64   bool Inherited : 1;
65 
66   virtual ~Attr();
67 
new(size_t bytes)68   void* operator new(size_t bytes) throw() {
69     llvm_unreachable("Attrs cannot be allocated with regular 'new'.");
70   }
delete(void * data)71   void operator delete(void* data) throw() {
72     llvm_unreachable("Attrs cannot be released with regular 'delete'.");
73   }
74 
75 public:
76   // Forward so that the regular new and delete do not hide global ones.
77   void* operator new(size_t Bytes, ASTContext &C,
throw()78                      size_t Alignment = 16) throw() {
79     return ::operator new(Bytes, C, Alignment);
80   }
delete(void * Ptr,ASTContext & C,size_t Alignment)81   void operator delete(void *Ptr, ASTContext &C,
82                        size_t Alignment) throw() {
83     return ::operator delete(Ptr, C, Alignment);
84   }
85 
86 protected:
Attr(attr::Kind AK,SourceRange R)87   Attr(attr::Kind AK, SourceRange R)
88     : Range(R), AttrKind(AK), Inherited(false) {}
89 
90 public:
91 
getKind()92   attr::Kind getKind() const {
93     return static_cast<attr::Kind>(AttrKind);
94   }
95 
getLocation()96   SourceLocation getLocation() const { return Range.getBegin(); }
getRange()97   SourceRange getRange() const { return Range; }
setRange(SourceRange R)98   void setRange(SourceRange R) { Range = R; }
99 
isInherited()100   bool isInherited() const { return Inherited; }
101 
102   // Clone this attribute.
103   virtual Attr* clone(ASTContext &C) const = 0;
104 
isLateParsed()105   virtual bool isLateParsed() const { return false; }
106 
107   // Pretty print this attribute.
108   virtual void printPretty(llvm::raw_ostream &OS, ASTContext &C) const = 0;
109 
110   // Implement isa/cast/dyncast/etc.
classof(const Attr *)111   static bool classof(const Attr *) { return true; }
112 };
113 
114 class InheritableAttr : public Attr {
115   virtual void anchor();
116 protected:
InheritableAttr(attr::Kind AK,SourceRange R)117   InheritableAttr(attr::Kind AK, SourceRange R)
118     : Attr(AK, R) {}
119 
120 public:
setInherited(bool I)121   void setInherited(bool I) { Inherited = I; }
122 
123   // Implement isa/cast/dyncast/etc.
classof(const Attr * A)124   static bool classof(const Attr *A) {
125     return A->getKind() <= attr::LAST_INHERITABLE;
126   }
classof(const InheritableAttr *)127   static bool classof(const InheritableAttr *) { return true; }
128 };
129 
130 class InheritableParamAttr : public InheritableAttr {
131   virtual void anchor();
132 protected:
InheritableParamAttr(attr::Kind AK,SourceRange R)133   InheritableParamAttr(attr::Kind AK, SourceRange R)
134     : InheritableAttr(AK, R) {}
135 
136 public:
137   // Implement isa/cast/dyncast/etc.
classof(const Attr * A)138   static bool classof(const Attr *A) {
139     return A->getKind() <= attr::LAST_INHERITABLE_PARAM;
140   }
classof(const InheritableParamAttr *)141   static bool classof(const InheritableParamAttr *) { return true; }
142 };
143 
144 #include "clang/AST/Attrs.inc"
145 
146 /// AttrVec - A vector of Attr, which is how they are stored on the AST.
147 typedef SmallVector<Attr*, 2> AttrVec;
148 typedef SmallVector<const Attr*, 2> ConstAttrVec;
149 
150 /// DestroyAttrs - Destroy the contents of an AttrVec.
DestroyAttrs(AttrVec & V,ASTContext & C)151 inline void DestroyAttrs (AttrVec& V, ASTContext &C) {
152 }
153 
154 /// specific_attr_iterator - Iterates over a subrange of an AttrVec, only
155 /// providing attributes that are of a specifc type.
156 template <typename SpecificAttr>
157 class specific_attr_iterator {
158   /// Current - The current, underlying iterator.
159   /// In order to ensure we don't dereference an invalid iterator unless
160   /// specifically requested, we don't necessarily advance this all the
161   /// way. Instead, we advance it when an operation is requested; if the
162   /// operation is acting on what should be a past-the-end iterator,
163   /// then we offer no guarantees, but this way we do not dererence a
164   /// past-the-end iterator when we move to a past-the-end position.
165   mutable AttrVec::const_iterator Current;
166 
AdvanceToNext()167   void AdvanceToNext() const {
168     while (!isa<SpecificAttr>(*Current))
169       ++Current;
170   }
171 
AdvanceToNext(AttrVec::const_iterator I)172   void AdvanceToNext(AttrVec::const_iterator I) const {
173     while (Current != I && !isa<SpecificAttr>(*Current))
174       ++Current;
175   }
176 
177 public:
178   typedef SpecificAttr*             value_type;
179   typedef SpecificAttr*             reference;
180   typedef SpecificAttr*             pointer;
181   typedef std::forward_iterator_tag iterator_category;
182   typedef std::ptrdiff_t            difference_type;
183 
specific_attr_iterator()184   specific_attr_iterator() : Current() { }
specific_attr_iterator(AttrVec::const_iterator i)185   explicit specific_attr_iterator(AttrVec::const_iterator i) : Current(i) { }
186 
187   reference operator*() const {
188     AdvanceToNext();
189     return cast<SpecificAttr>(*Current);
190   }
191   pointer operator->() const {
192     AdvanceToNext();
193     return cast<SpecificAttr>(*Current);
194   }
195 
196   specific_attr_iterator& operator++() {
197     ++Current;
198     return *this;
199   }
200   specific_attr_iterator operator++(int) {
201     specific_attr_iterator Tmp(*this);
202     ++(*this);
203     return Tmp;
204   }
205 
206   friend bool operator==(specific_attr_iterator Left,
207                          specific_attr_iterator Right) {
208     if (Left.Current < Right.Current)
209       Left.AdvanceToNext(Right.Current);
210     else
211       Right.AdvanceToNext(Left.Current);
212     return Left.Current == Right.Current;
213   }
214   friend bool operator!=(specific_attr_iterator Left,
215                          specific_attr_iterator Right) {
216     return !(Left == Right);
217   }
218 };
219 
220 template <typename T>
specific_attr_begin(const AttrVec & vec)221 inline specific_attr_iterator<T> specific_attr_begin(const AttrVec& vec) {
222   return specific_attr_iterator<T>(vec.begin());
223 }
224 template <typename T>
specific_attr_end(const AttrVec & vec)225 inline specific_attr_iterator<T> specific_attr_end(const AttrVec& vec) {
226   return specific_attr_iterator<T>(vec.end());
227 }
228 
229 template <typename T>
hasSpecificAttr(const AttrVec & vec)230 inline bool hasSpecificAttr(const AttrVec& vec) {
231   return specific_attr_begin<T>(vec) != specific_attr_end<T>(vec);
232 }
233 template <typename T>
getSpecificAttr(const AttrVec & vec)234 inline T *getSpecificAttr(const AttrVec& vec) {
235   specific_attr_iterator<T> i = specific_attr_begin<T>(vec);
236   if (i != specific_attr_end<T>(vec))
237     return *i;
238   else
239     return 0;
240 }
241 
242 /// getMaxAlignment - Returns the highest alignment value found among
243 /// AlignedAttrs in an AttrVec, or 0 if there are none.
getMaxAttrAlignment(const AttrVec & V,ASTContext & Ctx)244 inline unsigned getMaxAttrAlignment(const AttrVec& V, ASTContext &Ctx) {
245   unsigned Align = 0;
246   specific_attr_iterator<AlignedAttr> i(V.begin()), e(V.end());
247   for(; i != e; ++i)
248     Align = std::max(Align, i->getAlignment(Ctx));
249   return Align;
250 }
251 
252 }  // end namespace clang
253 
254 #endif
255