clang: lib/Sema/TypeLocBuilder.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
15
16using namespace clang;
17
21
24 while (CurTL) {
25 TypeLocs.push_back(CurTL);
27 }
28
29 for (unsigned i = 0, e = TypeLocs.size(); i < e; ++i) {
30 TypeLoc CurTL = TypeLocs[e-i-1];
32#define ABSTRACT_TYPELOC(CLASS, PARENT)
33#define TYPELOC(CLASS, PARENT) \
34 case TypeLoc::CLASS: { \
35 CLASS##TypeLoc NewTL = push<class CLASS##TypeLoc>(CurTL.getType()); \
36 memcpy(NewTL.getOpaqueData(), CurTL.getOpaqueData(), NewTL.getLocalDataSize()); \
37 break; \
38 }
39#include "clang/AST/TypeLocNodes.def"
40 }
41 }
42}
43
47 reserve(L.getFullDataSize());
48
50 for (auto CurTL = L; CurTL; CurTL = CurTL.getNextTypeLoc())
51 TypeLocs.push_back(CurTL);
52
53 for (const auto &CurTL : llvm::reverse(TypeLocs)) {
54 switch (CurTL.getTypeLocClass()) {
55#define ABSTRACT_TYPELOC(CLASS, PARENT)
56#define TYPELOC(CLASS, PARENT) \
57 case TypeLoc::CLASS: { \
58 auto NewTL = push<class CLASS##TypeLoc>(CurTL.getType()); \
59 NewTL.initializeLocal(Context, Loc); \
60 break; \
61 }
62#include "clang/AST/TypeLocNodes.def"
63 }
64 }
65}
66
67void TypeLocBuilder::grow(size_t NewCapacity) {
68 assert(NewCapacity > Capacity);
69
70
71 char *NewBuffer = new char[NewCapacity];
72 unsigned NewIndex = Index + NewCapacity - Capacity;
73 memcpy(&NewBuffer[NewIndex],
74 &Buffer[Index],
75 Capacity - Index);
76
77 if (Buffer != InlineBuffer)
78 delete[] Buffer;
79
80 Buffer = NewBuffer;
81 Capacity = NewCapacity;
82 Index = NewIndex;
83}
84
85TypeLoc TypeLocBuilder::pushImpl(QualType T, size_t LocalSize, unsigned LocalAlignment) {
86#ifndef NDEBUG
88 assert(TLast == LastTy &&
89 "mismatch between last type and new type's inner type");
90 LastTy = T;
91#endif
92
93 assert(LocalAlignment <= BufferMaxAlignment && "Unexpected alignment");
94
95
96 if (LocalSize > Index) {
97 size_t RequiredCapacity = Capacity + (LocalSize - Index);
98 size_t NewCapacity = Capacity * 2;
99 while (RequiredCapacity > NewCapacity)
100 NewCapacity *= 2;
101 grow(NewCapacity);
102 }
103
104
105
106
107
108
109
110 if (LocalAlignment == 4) {
111 if (!AtAlign8) {
112 NumBytesAtAlign4 += LocalSize;
113 } else {
114 unsigned Padding = NumBytesAtAlign4 % 8;
115 if (Padding == 0) {
116 if (LocalSize % 8 == 0) {
117
118
119 } else {
120 assert(LocalSize % 8 == 4);
121
122 memmove(&Buffer[Index - 4], &Buffer[Index], NumBytesAtAlign4);
123 Index -= 4;
124 }
125 } else {
126 assert(Padding == 4);
127 if (LocalSize % 8 == 0) {
128
129
130 } else {
131 assert(LocalSize % 8 == 4);
132
133 memmove(&Buffer[Index + 4], &Buffer[Index], NumBytesAtAlign4);
134 Index += 4;
135 }
136 }
137 NumBytesAtAlign4 += LocalSize;
138 }
139 } else if (LocalAlignment == 8) {
140 if (!AtAlign8) {
141
142
143 if ((Index - LocalSize) % 8 != 0) {
144 memmove(&Buffer[Index - 4], &Buffer[Index], NumBytesAtAlign4);
145 Index -= 4;
146 }
147 } else {
148 unsigned Padding = NumBytesAtAlign4 % 8;
149 if (Padding == 0) {
150 if (LocalSize % 8 == 0) {
151
152
153 } else {
154 assert(LocalSize % 8 == 4);
155
156 memmove(&Buffer[Index - 4], &Buffer[Index], NumBytesAtAlign4);
157 Index -= 4;
158 }
159 } else {
160 assert(Padding == 4);
161 if (LocalSize % 8 == 0) {
162
163
164 } else {
165 assert(LocalSize % 8 == 4);
166
167 memmove(&Buffer[Index + 4], &Buffer[Index], NumBytesAtAlign4);
168 Index += 4;
169 }
170 }
171 }
172
173
174 NumBytesAtAlign4 = 0;
175 AtAlign8 = true;
176 } else {
177 assert(LocalSize == 0);
178 }
179
180 Index -= LocalSize;
181
183 "incorrect data size provided to CreateTypeSourceInfo!");
184
185 return getTemporaryTypeLoc(T);
186}
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
A (possibly-)qualified type.
Encodes a location in the source.
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
void pushTrivial(ASTContext &Context, QualType T, SourceLocation Loc)
Pushes 'T' with all locations pointing to 'Loc'.
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
unsigned getFullDataSize() const
Returns the size of the type source info data block.
TypeLocClass getTypeLocClass() const
static unsigned getFullDataSizeForType(QualType Ty)
Returns the size of type source info data block for the given type.
The JSON file list parser is used to communicate input to InstallAPI.
const FunctionProtoType * T