Debian Codegraph @

llvm-project/clang/lib/Sema/TypeLocBuilder.h

raw
1 //===--- TypeLocBuilder.h - Type Source Info collector ----------*- 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 TypeLocBuilder, a class for building TypeLocs
10 // bottom-up.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_CLANG_LIB_SEMA_TYPELOCBUILDER_H
15 #define LLVM_CLANG_LIB_SEMA_TYPELOCBUILDER_H
16
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/TypeLoc.h"
19
20 namespace clang {
21
22 class TypeLocBuilder {
23 enum { InlineCapacity = 8 * sizeof(SourceLocation) };
24
25 /// The underlying location-data buffer. Data grows from the end
26 /// of the buffer backwards.
27 char *Buffer;
28
29 /// The capacity of the current buffer.
30 size_t Capacity;
31
32 /// The index of the first occupied byte in the buffer.
33 size_t Index;
34
35 #ifndef NDEBUG
36 /// The last type pushed on this builder.
37 QualType LastTy;
38 #endif
39
40 /// The inline buffer.
41 enum { BufferMaxAlignment = alignof(void *) };
42 alignas(BufferMaxAlignment) char InlineBuffer[InlineCapacity];
43 unsigned NumBytesAtAlign4;
44 bool AtAlign8;
45
46 public:
47 TypeLocBuilder()
48 : Buffer(InlineBuffer), Capacity(InlineCapacity), Index(InlineCapacity),
49 NumBytesAtAlign4(0), AtAlign8(false) {}
50
51 ~TypeLocBuilder() {
52 if (Buffer != InlineBuffer)
53 delete[] Buffer;
54 }
55
56 /// Ensures that this buffer has at least as much capacity as described.
57 void reserve(size_t Requested) {
58 if (Requested > Capacity)
59 // For now, match the request exactly.
60 grow(Requested);
61 }
62
63 /// Pushes a copy of the given TypeLoc onto this builder. The builder
64 /// must be empty for this to work.
65 void pushFullCopy(TypeLoc L);
66
67 /// Pushes 'T' with all locations pointing to 'Loc'.
68 /// The builder must be empty for this to work.
69 void pushTrivial(ASTContext &Context, QualType T, SourceLocation Loc);
70
71 /// Pushes space for a typespec TypeLoc. Invalidates any TypeLocs
72 /// previously retrieved from this builder.
73 TypeSpecTypeLoc pushTypeSpec(QualType T) {
74 size_t LocalSize = TypeSpecTypeLoc::LocalDataSize;
75 unsigned LocalAlign = TypeSpecTypeLoc::LocalDataAlignment;
76 return pushImpl(T, LocalSize, LocalAlign).castAs<TypeSpecTypeLoc>();
77 }
78
79 /// Resets this builder to the newly-initialized state.
80 void clear() {
81 #ifndef NDEBUG
82 LastTy = QualType();
83 #endif
84 Index = Capacity;
85 NumBytesAtAlign4 = 0;
86 AtAlign8 = false;
87 }
88
89 /// Tell the TypeLocBuilder that the type it is storing has been
90 /// modified in some safe way that doesn't affect type-location information.
91 void TypeWasModifiedSafely(QualType T) {
92 #ifndef NDEBUG
93 LastTy = T;
94 #endif
95 }
96
97 /// Pushes space for a new TypeLoc of the given type. Invalidates
98 /// any TypeLocs previously retrieved from this builder.
99 template <class TyLocType> TyLocType push(QualType T) {
100 TyLocType Loc = TypeLoc(T, nullptr).castAs<TyLocType>();
101 size_t LocalSize = Loc.getLocalDataSize();
102 unsigned LocalAlign = Loc.getLocalDataAlignment();
103 return pushImpl(T, LocalSize, LocalAlign).castAs<TyLocType>();
104 }
105
106 /// Creates a TypeSourceInfo for the given type.
107 TypeSourceInfo *getTypeSourceInfo(ASTContext& Context, QualType T) {
108 #ifndef NDEBUG
109 assert(T == LastTy && "type doesn't match last type pushed!");
110 #endif
111
112 size_t FullDataSize = Capacity - Index;
113 TypeSourceInfo *DI = Context.CreateTypeSourceInfo(T, FullDataSize);
114 memcpy(DI->getTypeLoc().getOpaqueData(), &Buffer[Index], FullDataSize);
115 return DI;
116 }
117
118 /// Copies the type-location information to the given AST context and
119 /// returns a \c TypeLoc referring into the AST context.
120 TypeLoc getTypeLocInContext(ASTContext &Context, QualType T) {
121 #ifndef NDEBUG
122 assert(T == LastTy && "type doesn't match last type pushed!");
123 #endif
124
125 size_t FullDataSize = Capacity - Index;
126 void *Mem = Context.Allocate(FullDataSize);
127 memcpy(Mem, &Buffer[Index], FullDataSize);
128 return TypeLoc(T, Mem);
129 }
130
131 private:
132
133 TypeLoc pushImpl(QualType T, size_t LocalSize, unsigned LocalAlignment);
134
135 /// Grow to the given capacity.
136 void grow(size_t NewCapacity);
137
138 /// Retrieve a temporary TypeLoc that refers into this \c TypeLocBuilder
139 /// object.
140 ///
141 /// The resulting \c TypeLoc should only be used so long as the
142 /// \c TypeLocBuilder is active and has not had more type information
143 /// pushed into it.
144 TypeLoc getTemporaryTypeLoc(QualType T) {
145 #ifndef NDEBUG
146 assert(LastTy == T && "type doesn't match last type pushed!");
147 #endif
148 return TypeLoc(T, &Buffer[Index]);
149 }
150 };
151
152 }
153
154 #endif