clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ASTReaderStmt.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSerialization/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSerialization/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSerialization/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSerialization/../include -I /usr/src/gnu/usr.bin/clang/libclangSerialization/obj -I /usr/src/gnu/usr.bin/clang/libclangSerialization/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSerialization/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSerialization/../../../llvm/clang/lib/Serialization/ASTReaderStmt.cpp
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | |
14 | #include "clang/AST/ASTConcept.h" |
15 | #include "clang/AST/ASTContext.h" |
16 | #include "clang/AST/AttrIterator.h" |
17 | #include "clang/AST/Decl.h" |
18 | #include "clang/AST/DeclAccessPair.h" |
19 | #include "clang/AST/DeclCXX.h" |
20 | #include "clang/AST/DeclGroup.h" |
21 | #include "clang/AST/DeclObjC.h" |
22 | #include "clang/AST/DeclTemplate.h" |
23 | #include "clang/AST/DeclarationName.h" |
24 | #include "clang/AST/DependenceFlags.h" |
25 | #include "clang/AST/Expr.h" |
26 | #include "clang/AST/ExprCXX.h" |
27 | #include "clang/AST/ExprObjC.h" |
28 | #include "clang/AST/ExprOpenMP.h" |
29 | #include "clang/AST/NestedNameSpecifier.h" |
30 | #include "clang/AST/OpenMPClause.h" |
31 | #include "clang/AST/OperationKinds.h" |
32 | #include "clang/AST/Stmt.h" |
33 | #include "clang/AST/StmtCXX.h" |
34 | #include "clang/AST/StmtObjC.h" |
35 | #include "clang/AST/StmtOpenMP.h" |
36 | #include "clang/AST/StmtVisitor.h" |
37 | #include "clang/AST/TemplateBase.h" |
38 | #include "clang/AST/Type.h" |
39 | #include "clang/AST/UnresolvedSet.h" |
40 | #include "clang/Basic/CapturedStmt.h" |
41 | #include "clang/Basic/ExpressionTraits.h" |
42 | #include "clang/Basic/LLVM.h" |
43 | #include "clang/Basic/Lambda.h" |
44 | #include "clang/Basic/LangOptions.h" |
45 | #include "clang/Basic/OpenMPKinds.h" |
46 | #include "clang/Basic/OperatorKinds.h" |
47 | #include "clang/Basic/SourceLocation.h" |
48 | #include "clang/Basic/Specifiers.h" |
49 | #include "clang/Basic/TypeTraits.h" |
50 | #include "clang/Lex/Token.h" |
51 | #include "clang/Serialization/ASTBitCodes.h" |
52 | #include "clang/Serialization/ASTRecordReader.h" |
53 | #include "llvm/ADT/BitmaskEnum.h" |
54 | #include "llvm/ADT/DenseMap.h" |
55 | #include "llvm/ADT/SmallString.h" |
56 | #include "llvm/ADT/SmallVector.h" |
57 | #include "llvm/ADT/StringRef.h" |
58 | #include "llvm/Bitstream/BitstreamReader.h" |
59 | #include "llvm/Support/Casting.h" |
60 | #include "llvm/Support/ErrorHandling.h" |
61 | #include <algorithm> |
62 | #include <cassert> |
63 | #include <cstdint> |
64 | #include <string> |
65 | |
66 | using namespace clang; |
67 | using namespace serialization; |
68 | |
69 | namespace clang { |
70 | |
71 | class ASTStmtReader : public StmtVisitor<ASTStmtReader> { |
72 | ASTRecordReader &Record; |
73 | llvm::BitstreamCursor &DeclsCursor; |
74 | |
75 | SourceLocation readSourceLocation() { |
76 | return Record.readSourceLocation(); |
77 | } |
78 | |
79 | SourceRange readSourceRange() { |
80 | return Record.readSourceRange(); |
81 | } |
82 | |
83 | std::string readString() { |
84 | return Record.readString(); |
85 | } |
86 | |
87 | TypeSourceInfo *readTypeSourceInfo() { |
88 | return Record.readTypeSourceInfo(); |
89 | } |
90 | |
91 | Decl *readDecl() { |
92 | return Record.readDecl(); |
93 | } |
94 | |
95 | template<typename T> |
96 | T *readDeclAs() { |
97 | return Record.readDeclAs<T>(); |
98 | } |
99 | |
100 | public: |
101 | ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor) |
102 | : Record(Record), DeclsCursor(Cursor) {} |
103 | |
104 | |
105 | |
106 | static const unsigned NumStmtFields = 0; |
107 | |
108 | |
109 | |
110 | static const unsigned NumExprFields = |
111 | NumStmtFields + llvm::BitWidth<ExprDependence> + 3; |
112 | |
113 | |
114 | void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, |
115 | TemplateArgumentLoc *ArgsLocArray, |
116 | unsigned NumTemplateArgs); |
117 | |
118 | |
119 | void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList, |
120 | unsigned NumTemplateArgs); |
121 | |
122 | void VisitStmt(Stmt *S); |
123 | #define STMT(Type, Base) \ |
124 | void Visit##Type(Type *); |
125 | #include "clang/AST/StmtNodes.inc" |
126 | }; |
127 | |
128 | } |
129 | |
130 | void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, |
131 | TemplateArgumentLoc *ArgsLocArray, |
132 | unsigned NumTemplateArgs) { |
133 | SourceLocation TemplateKWLoc = readSourceLocation(); |
134 | TemplateArgumentListInfo ArgInfo; |
135 | ArgInfo.setLAngleLoc(readSourceLocation()); |
136 | ArgInfo.setRAngleLoc(readSourceLocation()); |
137 | for (unsigned i = 0; i != NumTemplateArgs; ++i) |
138 | ArgInfo.addArgument(Record.readTemplateArgumentLoc()); |
139 | Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray); |
140 | } |
141 | |
142 | void ASTStmtReader::VisitStmt(Stmt *S) { |
143 | assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count"); |
144 | } |
145 | |
146 | void ASTStmtReader::VisitNullStmt(NullStmt *S) { |
147 | VisitStmt(S); |
148 | S->setSemiLoc(readSourceLocation()); |
149 | S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt(); |
150 | } |
151 | |
152 | void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) { |
153 | VisitStmt(S); |
154 | SmallVector<Stmt *, 16> Stmts; |
155 | unsigned NumStmts = Record.readInt(); |
156 | while (NumStmts--) |
157 | Stmts.push_back(Record.readSubStmt()); |
158 | S->setStmts(Stmts); |
159 | S->CompoundStmtBits.LBraceLoc = readSourceLocation(); |
160 | S->RBraceLoc = readSourceLocation(); |
161 | } |
162 | |
163 | void ASTStmtReader::VisitSwitchCase(SwitchCase *S) { |
164 | VisitStmt(S); |
165 | Record.recordSwitchCaseID(S, Record.readInt()); |
166 | S->setKeywordLoc(readSourceLocation()); |
167 | S->setColonLoc(readSourceLocation()); |
168 | } |
169 | |
170 | void ASTStmtReader::VisitCaseStmt(CaseStmt *S) { |
171 | VisitSwitchCase(S); |
172 | bool CaseStmtIsGNURange = Record.readInt(); |
173 | S->setLHS(Record.readSubExpr()); |
174 | S->setSubStmt(Record.readSubStmt()); |
175 | if (CaseStmtIsGNURange) { |
176 | S->setRHS(Record.readSubExpr()); |
177 | S->setEllipsisLoc(readSourceLocation()); |
178 | } |
179 | } |
180 | |
181 | void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) { |
182 | VisitSwitchCase(S); |
183 | S->setSubStmt(Record.readSubStmt()); |
184 | } |
185 | |
186 | void ASTStmtReader::VisitLabelStmt(LabelStmt *S) { |
187 | VisitStmt(S); |
188 | bool IsSideEntry = Record.readInt(); |
189 | auto *LD = readDeclAs<LabelDecl>(); |
190 | LD->setStmt(S); |
191 | S->setDecl(LD); |
192 | S->setSubStmt(Record.readSubStmt()); |
193 | S->setIdentLoc(readSourceLocation()); |
194 | S->setSideEntry(IsSideEntry); |
195 | } |
196 | |
197 | void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) { |
198 | VisitStmt(S); |
199 | |
200 | |
201 | |
202 | uint64_t NumAttrs = Record.readInt(); |
203 | AttrVec Attrs; |
204 | Record.readAttributes(Attrs); |
205 | (void)NumAttrs; |
206 | assert(NumAttrs == S->AttributedStmtBits.NumAttrs); |
207 | assert(NumAttrs == Attrs.size()); |
208 | std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr()); |
209 | S->SubStmt = Record.readSubStmt(); |
210 | S->AttributedStmtBits.AttrLoc = readSourceLocation(); |
211 | } |
212 | |
213 | void ASTStmtReader::VisitIfStmt(IfStmt *S) { |
214 | VisitStmt(S); |
215 | |
216 | S->setConstexpr(Record.readInt()); |
217 | bool HasElse = Record.readInt(); |
218 | bool HasVar = Record.readInt(); |
219 | bool HasInit = Record.readInt(); |
220 | |
221 | S->setCond(Record.readSubExpr()); |
222 | S->setThen(Record.readSubStmt()); |
223 | if (HasElse) |
224 | S->setElse(Record.readSubStmt()); |
225 | if (HasVar) |
226 | S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>()); |
227 | if (HasInit) |
228 | S->setInit(Record.readSubStmt()); |
229 | |
230 | S->setIfLoc(readSourceLocation()); |
231 | S->setLParenLoc(readSourceLocation()); |
232 | S->setRParenLoc(readSourceLocation()); |
233 | if (HasElse) |
234 | S->setElseLoc(readSourceLocation()); |
235 | } |
236 | |
237 | void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) { |
238 | VisitStmt(S); |
239 | |
240 | bool HasInit = Record.readInt(); |
241 | bool HasVar = Record.readInt(); |
242 | bool AllEnumCasesCovered = Record.readInt(); |
243 | if (AllEnumCasesCovered) |
244 | S->setAllEnumCasesCovered(); |
245 | |
246 | S->setCond(Record.readSubExpr()); |
247 | S->setBody(Record.readSubStmt()); |
248 | if (HasInit) |
249 | S->setInit(Record.readSubStmt()); |
250 | if (HasVar) |
251 | S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>()); |
252 | |
253 | S->setSwitchLoc(readSourceLocation()); |
254 | S->setLParenLoc(readSourceLocation()); |
255 | S->setRParenLoc(readSourceLocation()); |
256 | |
257 | SwitchCase *PrevSC = nullptr; |
258 | for (auto E = Record.size(); Record.getIdx() != E; ) { |
259 | SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt()); |
260 | if (PrevSC) |
261 | PrevSC->setNextSwitchCase(SC); |
262 | else |
263 | S->setSwitchCaseList(SC); |
264 | |
265 | PrevSC = SC; |
266 | } |
267 | } |
268 | |
269 | void ASTStmtReader::VisitWhileStmt(WhileStmt *S) { |
270 | VisitStmt(S); |
271 | |
272 | bool HasVar = Record.readInt(); |
273 | |
274 | S->setCond(Record.readSubExpr()); |
275 | S->setBody(Record.readSubStmt()); |
276 | if (HasVar) |
277 | S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>()); |
278 | |
279 | S->setWhileLoc(readSourceLocation()); |
280 | S->setLParenLoc(readSourceLocation()); |
281 | S->setRParenLoc(readSourceLocation()); |
282 | } |
283 | |
284 | void ASTStmtReader::VisitDoStmt(DoStmt *S) { |
285 | VisitStmt(S); |
286 | S->setCond(Record.readSubExpr()); |
287 | S->setBody(Record.readSubStmt()); |
288 | S->setDoLoc(readSourceLocation()); |
289 | S->setWhileLoc(readSourceLocation()); |
290 | S->setRParenLoc(readSourceLocation()); |
291 | } |
292 | |
293 | void ASTStmtReader::VisitForStmt(ForStmt *S) { |
294 | VisitStmt(S); |
295 | S->setInit(Record.readSubStmt()); |
296 | S->setCond(Record.readSubExpr()); |
297 | S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>()); |
298 | S->setInc(Record.readSubExpr()); |
299 | S->setBody(Record.readSubStmt()); |
300 | S->setForLoc(readSourceLocation()); |
301 | S->setLParenLoc(readSourceLocation()); |
302 | S->setRParenLoc(readSourceLocation()); |
303 | } |
304 | |
305 | void ASTStmtReader::VisitGotoStmt(GotoStmt *S) { |
306 | VisitStmt(S); |
307 | S->setLabel(readDeclAs<LabelDecl>()); |
308 | S->setGotoLoc(readSourceLocation()); |
309 | S->setLabelLoc(readSourceLocation()); |
310 | } |
311 | |
312 | void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) { |
313 | VisitStmt(S); |
314 | S->setGotoLoc(readSourceLocation()); |
315 | S->setStarLoc(readSourceLocation()); |
316 | S->setTarget(Record.readSubExpr()); |
317 | } |
318 | |
319 | void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) { |
320 | VisitStmt(S); |
321 | S->setContinueLoc(readSourceLocation()); |
322 | } |
323 | |
324 | void ASTStmtReader::VisitBreakStmt(BreakStmt *S) { |
325 | VisitStmt(S); |
326 | S->setBreakLoc(readSourceLocation()); |
327 | } |
328 | |
329 | void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) { |
330 | VisitStmt(S); |
331 | |
332 | bool HasNRVOCandidate = Record.readInt(); |
333 | |
334 | S->setRetValue(Record.readSubExpr()); |
335 | if (HasNRVOCandidate) |
336 | S->setNRVOCandidate(readDeclAs<VarDecl>()); |
337 | |
338 | S->setReturnLoc(readSourceLocation()); |
339 | } |
340 | |
341 | void ASTStmtReader::VisitDeclStmt(DeclStmt *S) { |
342 | VisitStmt(S); |
343 | S->setStartLoc(readSourceLocation()); |
344 | S->setEndLoc(readSourceLocation()); |
345 | |
346 | if (Record.size() - Record.getIdx() == 1) { |
347 | |
348 | S->setDeclGroup(DeclGroupRef(readDecl())); |
349 | } else { |
350 | SmallVector<Decl *, 16> Decls; |
351 | int N = Record.size() - Record.getIdx(); |
352 | Decls.reserve(N); |
353 | for (int I = 0; I < N; ++I) |
354 | Decls.push_back(readDecl()); |
355 | S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(), |
356 | Decls.data(), |
357 | Decls.size()))); |
358 | } |
359 | } |
360 | |
361 | void ASTStmtReader::VisitAsmStmt(AsmStmt *S) { |
362 | VisitStmt(S); |
363 | S->NumOutputs = Record.readInt(); |
364 | S->NumInputs = Record.readInt(); |
365 | S->NumClobbers = Record.readInt(); |
366 | S->setAsmLoc(readSourceLocation()); |
367 | S->setVolatile(Record.readInt()); |
368 | S->setSimple(Record.readInt()); |
369 | } |
370 | |
371 | void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) { |
372 | VisitAsmStmt(S); |
373 | S->NumLabels = Record.readInt(); |
374 | S->setRParenLoc(readSourceLocation()); |
375 | S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt())); |
376 | |
377 | unsigned NumOutputs = S->getNumOutputs(); |
378 | unsigned NumInputs = S->getNumInputs(); |
379 | unsigned NumClobbers = S->getNumClobbers(); |
380 | unsigned NumLabels = S->getNumLabels(); |
381 | |
382 | |
383 | SmallVector<IdentifierInfo *, 16> Names; |
384 | SmallVector<StringLiteral*, 16> Constraints; |
385 | SmallVector<Stmt*, 16> Exprs; |
386 | for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) { |
387 | Names.push_back(Record.readIdentifier()); |
388 | Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt())); |
389 | Exprs.push_back(Record.readSubStmt()); |
390 | } |
391 | |
392 | |
393 | SmallVector<StringLiteral*, 16> Clobbers; |
394 | for (unsigned I = 0; I != NumClobbers; ++I) |
395 | Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt())); |
396 | |
397 | |
398 | for (unsigned I = 0, N = NumLabels; I != N; ++I) |
399 | Exprs.push_back(Record.readSubStmt()); |
400 | |
401 | S->setOutputsAndInputsAndClobbers(Record.getContext(), |
402 | Names.data(), Constraints.data(), |
403 | Exprs.data(), NumOutputs, NumInputs, |
404 | NumLabels, |
405 | Clobbers.data(), NumClobbers); |
406 | } |
407 | |
408 | void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) { |
409 | VisitAsmStmt(S); |
410 | S->LBraceLoc = readSourceLocation(); |
411 | S->EndLoc = readSourceLocation(); |
412 | S->NumAsmToks = Record.readInt(); |
413 | std::string AsmStr = readString(); |
414 | |
415 | |
416 | SmallVector<Token, 16> AsmToks; |
417 | AsmToks.reserve(S->NumAsmToks); |
418 | for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) { |
419 | AsmToks.push_back(Record.readToken()); |
420 | } |
421 | |
422 | |
423 | |
424 | |
425 | |
426 | SmallVector<std::string, 16> ClobbersData; |
427 | SmallVector<StringRef, 16> Clobbers; |
428 | ClobbersData.reserve(S->NumClobbers); |
429 | Clobbers.reserve(S->NumClobbers); |
430 | for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) { |
431 | ClobbersData.push_back(readString()); |
432 | Clobbers.push_back(ClobbersData.back()); |
433 | } |
434 | |
435 | |
436 | unsigned NumOperands = S->NumOutputs + S->NumInputs; |
437 | SmallVector<Expr*, 16> Exprs; |
438 | SmallVector<std::string, 16> ConstraintsData; |
439 | SmallVector<StringRef, 16> Constraints; |
440 | Exprs.reserve(NumOperands); |
441 | ConstraintsData.reserve(NumOperands); |
442 | Constraints.reserve(NumOperands); |
443 | for (unsigned i = 0; i != NumOperands; ++i) { |
444 | Exprs.push_back(cast<Expr>(Record.readSubStmt())); |
445 | ConstraintsData.push_back(readString()); |
446 | Constraints.push_back(ConstraintsData.back()); |
447 | } |
448 | |
449 | S->initialize(Record.getContext(), AsmStr, AsmToks, |
450 | Constraints, Exprs, Clobbers); |
451 | } |
452 | |
453 | void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { |
454 | VisitStmt(S); |
455 | assert(Record.peekInt() == S->NumParams); |
456 | Record.skipInts(1); |
457 | auto *StoredStmts = S->getStoredStmts(); |
458 | for (unsigned i = 0; |
459 | i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i) |
460 | StoredStmts[i] = Record.readSubStmt(); |
461 | } |
462 | |
463 | void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) { |
464 | VisitStmt(S); |
465 | S->CoreturnLoc = Record.readSourceLocation(); |
466 | for (auto &SubStmt: S->SubStmts) |
467 | SubStmt = Record.readSubStmt(); |
468 | S->IsImplicit = Record.readInt() != 0; |
469 | } |
470 | |
471 | void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) { |
472 | VisitExpr(E); |
473 | E->KeywordLoc = readSourceLocation(); |
474 | for (auto &SubExpr: E->SubExprs) |
475 | SubExpr = Record.readSubStmt(); |
476 | E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt()); |
477 | E->setIsImplicit(Record.readInt() != 0); |
478 | } |
479 | |
480 | void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) { |
481 | VisitExpr(E); |
482 | E->KeywordLoc = readSourceLocation(); |
483 | for (auto &SubExpr: E->SubExprs) |
484 | SubExpr = Record.readSubStmt(); |
485 | E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt()); |
486 | } |
487 | |
488 | void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) { |
489 | VisitExpr(E); |
490 | E->KeywordLoc = readSourceLocation(); |
491 | for (auto &SubExpr: E->SubExprs) |
492 | SubExpr = Record.readSubStmt(); |
493 | } |
494 | |
495 | void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) { |
496 | VisitStmt(S); |
497 | Record.skipInts(1); |
498 | S->setCapturedDecl(readDeclAs<CapturedDecl>()); |
499 | S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt())); |
500 | S->setCapturedRecordDecl(readDeclAs<RecordDecl>()); |
501 | |
502 | |
503 | for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(), |
504 | E = S->capture_init_end(); |
505 | I != E; ++I) |
506 | *I = Record.readSubExpr(); |
507 | |
508 | |
509 | S->setCapturedStmt(Record.readSubStmt()); |
510 | S->getCapturedDecl()->setBody(S->getCapturedStmt()); |
511 | |
512 | |
513 | for (auto &I : S->captures()) { |
514 | I.VarAndKind.setPointer(readDeclAs<VarDecl>()); |
515 | I.VarAndKind.setInt( |
516 | static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt())); |
517 | I.Loc = readSourceLocation(); |
518 | } |
519 | } |
520 | |
521 | void ASTStmtReader::VisitExpr(Expr *E) { |
522 | VisitStmt(E); |
523 | E->setType(Record.readType()); |
524 | |
525 | |
526 | bool TypeDependent = Record.readInt(); |
527 | bool ValueDependent = Record.readInt(); |
528 | bool InstantiationDependent = Record.readInt(); |
529 | bool ContainsUnexpandedTemplateParameters = Record.readInt(); |
530 | bool ContainsErrors = Record.readInt(); |
531 | auto Deps = ExprDependence::None; |
532 | if (TypeDependent) |
533 | Deps |= ExprDependence::Type; |
534 | if (ValueDependent) |
535 | Deps |= ExprDependence::Value; |
536 | if (InstantiationDependent) |
537 | Deps |= ExprDependence::Instantiation; |
538 | if (ContainsUnexpandedTemplateParameters) |
539 | Deps |= ExprDependence::UnexpandedPack; |
540 | if (ContainsErrors) |
541 | Deps |= ExprDependence::Error; |
542 | E->setDependence(Deps); |
543 | |
544 | E->setValueKind(static_cast<ExprValueKind>(Record.readInt())); |
545 | E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt())); |
546 | assert(Record.getIdx() == NumExprFields && |
547 | "Incorrect expression field count"); |
548 | } |
549 | |
550 | void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) { |
551 | VisitExpr(E); |
552 | |
553 | auto StorageKind = Record.readInt(); |
554 | assert(E->ConstantExprBits.ResultKind == StorageKind && "Wrong ResultKind!"); |
555 | |
556 | E->ConstantExprBits.APValueKind = Record.readInt(); |
557 | E->ConstantExprBits.IsUnsigned = Record.readInt(); |
558 | E->ConstantExprBits.BitWidth = Record.readInt(); |
559 | E->ConstantExprBits.HasCleanup = false; |
560 | E->ConstantExprBits.IsImmediateInvocation = Record.readInt(); |
561 | |
562 | switch (StorageKind) { |
563 | case ConstantExpr::RSK_None: |
564 | break; |
565 | |
566 | case ConstantExpr::RSK_Int64: |
567 | E->Int64Result() = Record.readInt(); |
568 | break; |
569 | |
570 | case ConstantExpr::RSK_APValue: |
571 | E->APValueResult() = Record.readAPValue(); |
572 | if (E->APValueResult().needsCleanup()) { |
573 | E->ConstantExprBits.HasCleanup = true; |
574 | Record.getContext().addDestruction(&E->APValueResult()); |
575 | } |
576 | break; |
577 | default: |
578 | llvm_unreachable("unexpected ResultKind!"); |
579 | } |
580 | |
581 | E->setSubExpr(Record.readSubExpr()); |
582 | } |
583 | |
584 | void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) { |
585 | VisitExpr(E); |
586 | |
587 | E->setLocation(readSourceLocation()); |
588 | E->setLParenLocation(readSourceLocation()); |
589 | E->setRParenLocation(readSourceLocation()); |
590 | |
591 | E->setTypeSourceInfo(Record.readTypeSourceInfo()); |
592 | } |
593 | |
594 | void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) { |
595 | VisitExpr(E); |
596 | bool HasFunctionName = Record.readInt(); |
597 | E->PredefinedExprBits.HasFunctionName = HasFunctionName; |
598 | E->PredefinedExprBits.Kind = Record.readInt(); |
599 | E->setLocation(readSourceLocation()); |
600 | if (HasFunctionName) |
601 | E->setFunctionName(cast<StringLiteral>(Record.readSubExpr())); |
602 | } |
603 | |
604 | void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) { |
605 | VisitExpr(E); |
606 | |
607 | E->DeclRefExprBits.HasQualifier = Record.readInt(); |
608 | E->DeclRefExprBits.HasFoundDecl = Record.readInt(); |
609 | E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt(); |
610 | E->DeclRefExprBits.HadMultipleCandidates = Record.readInt(); |
611 | E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt(); |
612 | E->DeclRefExprBits.NonOdrUseReason = Record.readInt(); |
613 | unsigned NumTemplateArgs = 0; |
614 | if (E->hasTemplateKWAndArgsInfo()) |
615 | NumTemplateArgs = Record.readInt(); |
616 | |
617 | if (E->hasQualifier()) |
618 | new (E->getTrailingObjects<NestedNameSpecifierLoc>()) |
619 | NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc()); |
620 | |
621 | if (E->hasFoundDecl()) |
622 | *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>(); |
623 | |
624 | if (E->hasTemplateKWAndArgsInfo()) |
625 | ReadTemplateKWAndArgsInfo( |
626 | *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), |
627 | E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); |
628 | |
629 | E->D = readDeclAs<ValueDecl>(); |
630 | E->setLocation(readSourceLocation()); |
631 | E->DNLoc = Record.readDeclarationNameLoc(E->getDecl()->getDeclName()); |
632 | } |
633 | |
634 | void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) { |
635 | VisitExpr(E); |
636 | E->setLocation(readSourceLocation()); |
637 | E->setValue(Record.getContext(), Record.readAPInt()); |
638 | } |
639 | |
640 | void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) { |
641 | VisitExpr(E); |
642 | E->setLocation(readSourceLocation()); |
643 | E->setScale(Record.readInt()); |
644 | E->setValue(Record.getContext(), Record.readAPInt()); |
645 | } |
646 | |
647 | void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) { |
648 | VisitExpr(E); |
649 | E->setRawSemantics( |
650 | static_cast<llvm::APFloatBase::Semantics>(Record.readInt())); |
651 | E->setExact(Record.readInt()); |
652 | E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics())); |
653 | E->setLocation(readSourceLocation()); |
654 | } |
655 | |
656 | void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) { |
657 | VisitExpr(E); |
658 | E->setSubExpr(Record.readSubExpr()); |
659 | } |
660 | |
661 | void ASTStmtReader::VisitStringLiteral(StringLiteral *E) { |
662 | VisitExpr(E); |
663 | |
664 | |
665 | |
666 | unsigned NumConcatenated = Record.readInt(); |
667 | unsigned Length = Record.readInt(); |
668 | unsigned CharByteWidth = Record.readInt(); |
669 | assert((NumConcatenated == E->getNumConcatenated()) && |
670 | "Wrong number of concatenated tokens!"); |
671 | assert((Length == E->getLength()) && "Wrong Length!"); |
672 | assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!"); |
673 | E->StringLiteralBits.Kind = Record.readInt(); |
674 | E->StringLiteralBits.IsPascal = Record.readInt(); |
675 | |
676 | |
677 | |
678 | |
679 | assert((CharByteWidth == |
680 | StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(), |
681 | E->getKind())) && |
682 | "Wrong character width!"); |
683 | |
684 | |
685 | for (unsigned I = 0; I < NumConcatenated; ++I) |
686 | E->setStrTokenLoc(I, readSourceLocation()); |
687 | |
688 | |
689 | char *StrData = E->getStrDataAsChar(); |
690 | for (unsigned I = 0; I < Length * CharByteWidth; ++I) |
691 | StrData[I] = Record.readInt(); |
692 | } |
693 | |
694 | void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) { |
695 | VisitExpr(E); |
696 | E->setValue(Record.readInt()); |
697 | E->setLocation(readSourceLocation()); |
698 | E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt())); |
699 | } |
700 | |
701 | void ASTStmtReader::VisitParenExpr(ParenExpr *E) { |
702 | VisitExpr(E); |
703 | E->setLParen(readSourceLocation()); |
704 | E->setRParen(readSourceLocation()); |
705 | E->setSubExpr(Record.readSubExpr()); |
706 | } |
707 | |
708 | void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) { |
709 | VisitExpr(E); |
710 | unsigned NumExprs = Record.readInt(); |
711 | assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!"); |
712 | for (unsigned I = 0; I != NumExprs; ++I) |
713 | E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt(); |
714 | E->LParenLoc = readSourceLocation(); |
715 | E->RParenLoc = readSourceLocation(); |
716 | } |
717 | |
718 | void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) { |
719 | VisitExpr(E); |
720 | bool hasFP_Features = Record.readInt(); |
721 | assert(hasFP_Features == E->hasStoredFPFeatures()); |
722 | E->setSubExpr(Record.readSubExpr()); |
723 | E->setOpcode((UnaryOperator::Opcode)Record.readInt()); |
724 | E->setOperatorLoc(readSourceLocation()); |
725 | E->setCanOverflow(Record.readInt()); |
726 | if (hasFP_Features) |
727 | E->setStoredFPFeatures( |
728 | FPOptionsOverride::getFromOpaqueInt(Record.readInt())); |
729 | } |
730 | |
731 | void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) { |
732 | VisitExpr(E); |
733 | assert(E->getNumComponents() == Record.peekInt()); |
734 | Record.skipInts(1); |
735 | assert(E->getNumExpressions() == Record.peekInt()); |
736 | Record.skipInts(1); |
737 | E->setOperatorLoc(readSourceLocation()); |
738 | E->setRParenLoc(readSourceLocation()); |
739 | E->setTypeSourceInfo(readTypeSourceInfo()); |
740 | for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { |
741 | auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt()); |
742 | SourceLocation Start = readSourceLocation(); |
743 | SourceLocation End = readSourceLocation(); |
744 | switch (Kind) { |
745 | case OffsetOfNode::Array: |
746 | E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End)); |
747 | break; |
748 | |
749 | case OffsetOfNode::Field: |
750 | E->setComponent( |
751 | I, OffsetOfNode(Start, readDeclAs<FieldDecl>(), End)); |
752 | break; |
753 | |
754 | case OffsetOfNode::Identifier: |
755 | E->setComponent( |
756 | I, |
757 | OffsetOfNode(Start, Record.readIdentifier(), End)); |
758 | break; |
759 | |
760 | case OffsetOfNode::Base: { |
761 | auto *Base = new (Record.getContext()) CXXBaseSpecifier(); |
762 | *Base = Record.readCXXBaseSpecifier(); |
763 | E->setComponent(I, OffsetOfNode(Base)); |
764 | break; |
765 | } |
766 | } |
767 | } |
768 | |
769 | for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) |
770 | E->setIndexExpr(I, Record.readSubExpr()); |
771 | } |
772 | |
773 | void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { |
774 | VisitExpr(E); |
775 | E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt())); |
776 | if (Record.peekInt() == 0) { |
777 | E->setArgument(Record.readSubExpr()); |
778 | Record.skipInts(1); |
779 | } else { |
780 | E->setArgument(readTypeSourceInfo()); |
781 | } |
782 | E->setOperatorLoc(readSourceLocation()); |
783 | E->setRParenLoc(readSourceLocation()); |
784 | } |
785 | |
786 | static ConstraintSatisfaction |
787 | readConstraintSatisfaction(ASTRecordReader &Record) { |
788 | ConstraintSatisfaction Satisfaction; |
789 | Satisfaction.IsSatisfied = Record.readInt(); |
790 | if (!Satisfaction.IsSatisfied) { |
791 | unsigned NumDetailRecords = Record.readInt(); |
792 | for (unsigned i = 0; i != NumDetailRecords; ++i) { |
793 | Expr *ConstraintExpr = Record.readExpr(); |
794 | if (Record.readInt()) { |
795 | SourceLocation DiagLocation = Record.readSourceLocation(); |
796 | std::string DiagMessage = Record.readString(); |
797 | Satisfaction.Details.emplace_back( |
798 | ConstraintExpr, new (Record.getContext()) |
799 | ConstraintSatisfaction::SubstitutionDiagnostic{ |
800 | DiagLocation, DiagMessage}); |
801 | } else |
802 | Satisfaction.Details.emplace_back(ConstraintExpr, Record.readExpr()); |
803 | } |
804 | } |
805 | return Satisfaction; |
806 | } |
807 | |
808 | void ASTStmtReader::VisitConceptSpecializationExpr( |
809 | ConceptSpecializationExpr *E) { |
810 | VisitExpr(E); |
811 | unsigned NumTemplateArgs = Record.readInt(); |
812 | E->NestedNameSpec = Record.readNestedNameSpecifierLoc(); |
813 | E->TemplateKWLoc = Record.readSourceLocation(); |
814 | E->ConceptName = Record.readDeclarationNameInfo(); |
815 | E->NamedConcept = readDeclAs<ConceptDecl>(); |
816 | E->FoundDecl = Record.readDeclAs<NamedDecl>(); |
817 | E->ArgsAsWritten = Record.readASTTemplateArgumentListInfo(); |
818 | llvm::SmallVector<TemplateArgument, 4> Args; |
819 | for (unsigned I = 0; I < NumTemplateArgs; ++I) |
820 | Args.push_back(Record.readTemplateArgument()); |
821 | E->setTemplateArguments(Args); |
822 | E->Satisfaction = E->isValueDependent() ? nullptr : |
823 | ASTConstraintSatisfaction::Create(Record.getContext(), |
824 | readConstraintSatisfaction(Record)); |
825 | } |
826 | |
827 | static concepts::Requirement::SubstitutionDiagnostic * |
828 | readSubstitutionDiagnostic(ASTRecordReader &Record) { |
829 | std::string SubstitutedEntity = Record.readString(); |
830 | SourceLocation DiagLoc = Record.readSourceLocation(); |
831 | std::string DiagMessage = Record.readString(); |
832 | return new (Record.getContext()) |
833 | concepts::Requirement::SubstitutionDiagnostic{SubstitutedEntity, DiagLoc, |
834 | DiagMessage}; |
835 | } |
836 | |
837 | void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) { |
838 | VisitExpr(E); |
839 | unsigned NumLocalParameters = Record.readInt(); |
840 | unsigned NumRequirements = Record.readInt(); |
841 | E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation(); |
842 | E->RequiresExprBits.IsSatisfied = Record.readInt(); |
843 | E->Body = Record.readDeclAs<RequiresExprBodyDecl>(); |
844 | llvm::SmallVector<ParmVarDecl *, 4> LocalParameters; |
845 | for (unsigned i = 0; i < NumLocalParameters; ++i) |
846 | LocalParameters.push_back(cast<ParmVarDecl>(Record.readDecl())); |
847 | std::copy(LocalParameters.begin(), LocalParameters.end(), |
848 | E->getTrailingObjects<ParmVarDecl *>()); |
849 | llvm::SmallVector<concepts::Requirement *, 4> Requirements; |
850 | for (unsigned i = 0; i < NumRequirements; ++i) { |
851 | auto RK = |
852 | static_cast<concepts::Requirement::RequirementKind>(Record.readInt()); |
853 | concepts::Requirement *R = nullptr; |
854 | switch (RK) { |
855 | case concepts::Requirement::RK_Type: { |
856 | auto Status = |
857 | static_cast<concepts::TypeRequirement::SatisfactionStatus>( |
858 | Record.readInt()); |
859 | if (Status == concepts::TypeRequirement::SS_SubstitutionFailure) |
860 | R = new (Record.getContext()) |
861 | concepts::TypeRequirement(readSubstitutionDiagnostic(Record)); |
862 | else |
863 | R = new (Record.getContext()) |
864 | concepts::TypeRequirement(Record.readTypeSourceInfo()); |
865 | } break; |
866 | case concepts::Requirement::RK_Simple: |
867 | case concepts::Requirement::RK_Compound: { |
868 | auto Status = |
869 | static_cast<concepts::ExprRequirement::SatisfactionStatus>( |
870 | Record.readInt()); |
871 | llvm::PointerUnion<concepts::Requirement::SubstitutionDiagnostic *, |
872 | Expr *> E; |
873 | if (Status == concepts::ExprRequirement::SS_ExprSubstitutionFailure) { |
874 | E = readSubstitutionDiagnostic(Record); |
875 | } else |
876 | E = Record.readExpr(); |
877 | |
878 | llvm::Optional<concepts::ExprRequirement::ReturnTypeRequirement> Req; |
879 | ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr; |
880 | SourceLocation NoexceptLoc; |
881 | if (RK == concepts::Requirement::RK_Simple) { |
882 | Req.emplace(); |
883 | } else { |
884 | NoexceptLoc = Record.readSourceLocation(); |
885 | switch (Record.readInt()) { |
886 | case 0: |
887 | |
888 | Req.emplace(); |
889 | break; |
890 | case 1: { |
891 | |
892 | TemplateParameterList *TPL = Record.readTemplateParameterList(); |
893 | if (Status >= |
894 | concepts::ExprRequirement::SS_ConstraintsNotSatisfied) |
895 | SubstitutedConstraintExpr = |
896 | cast<ConceptSpecializationExpr>(Record.readExpr()); |
897 | Req.emplace(TPL); |
898 | } break; |
899 | case 2: |
900 | |
901 | Req.emplace(readSubstitutionDiagnostic(Record)); |
902 | break; |
903 | } |
904 | } |
905 | if (Expr *Ex = E.dyn_cast<Expr *>()) |
906 | R = new (Record.getContext()) concepts::ExprRequirement( |
907 | Ex, RK == concepts::Requirement::RK_Simple, NoexceptLoc, |
908 | std::move(*Req), Status, SubstitutedConstraintExpr); |
909 | else |
910 | R = new (Record.getContext()) concepts::ExprRequirement( |
911 | E.get<concepts::Requirement::SubstitutionDiagnostic *>(), |
912 | RK == concepts::Requirement::RK_Simple, NoexceptLoc, |
913 | std::move(*Req)); |
914 | } break; |
915 | case concepts::Requirement::RK_Nested: { |
916 | if (Record.readInt()) { |
917 | R = new (Record.getContext()) concepts::NestedRequirement( |
918 | readSubstitutionDiagnostic(Record)); |
919 | break; |
920 | } |
921 | Expr *E = Record.readExpr(); |
922 | if (E->isInstantiationDependent()) |
923 | R = new (Record.getContext()) concepts::NestedRequirement(E); |
924 | else |
925 | R = new (Record.getContext()) |
926 | concepts::NestedRequirement(Record.getContext(), E, |
927 | readConstraintSatisfaction(Record)); |
928 | } break; |
929 | } |
930 | if (!R) |
931 | continue; |
932 | Requirements.push_back(R); |
933 | } |
934 | std::copy(Requirements.begin(), Requirements.end(), |
935 | E->getTrailingObjects<concepts::Requirement *>()); |
936 | E->RBraceLoc = Record.readSourceLocation(); |
937 | } |
938 | |
939 | void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { |
940 | VisitExpr(E); |
941 | E->setLHS(Record.readSubExpr()); |
942 | E->setRHS(Record.readSubExpr()); |
943 | E->setRBracketLoc(readSourceLocation()); |
944 | } |
945 | |
946 | void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) { |
947 | VisitExpr(E); |
948 | E->setBase(Record.readSubExpr()); |
949 | E->setRowIdx(Record.readSubExpr()); |
950 | E->setColumnIdx(Record.readSubExpr()); |
951 | E->setRBracketLoc(readSourceLocation()); |
952 | } |
953 | |
954 | void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) { |
955 | VisitExpr(E); |
956 | E->setBase(Record.readSubExpr()); |
957 | E->setLowerBound(Record.readSubExpr()); |
958 | E->setLength(Record.readSubExpr()); |
959 | E->setStride(Record.readSubExpr()); |
960 | E->setColonLocFirst(readSourceLocation()); |
961 | E->setColonLocSecond(readSourceLocation()); |
962 | E->setRBracketLoc(readSourceLocation()); |
963 | } |
964 | |
965 | void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) { |
966 | VisitExpr(E); |
967 | unsigned NumDims = Record.readInt(); |
968 | E->setBase(Record.readSubExpr()); |
969 | SmallVector<Expr *, 4> Dims(NumDims); |
970 | for (unsigned I = 0; I < NumDims; ++I) |
971 | Dims[I] = Record.readSubExpr(); |
972 | E->setDimensions(Dims); |
973 | SmallVector<SourceRange, 4> SRs(NumDims); |
974 | for (unsigned I = 0; I < NumDims; ++I) |
975 | SRs[I] = readSourceRange(); |
976 | E->setBracketsRanges(SRs); |
977 | E->setLParenLoc(readSourceLocation()); |
978 | E->setRParenLoc(readSourceLocation()); |
979 | } |
980 | |
981 | void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) { |
982 | VisitExpr(E); |
983 | unsigned NumIters = Record.readInt(); |
984 | E->setIteratorKwLoc(readSourceLocation()); |
985 | E->setLParenLoc(readSourceLocation()); |
986 | E->setRParenLoc(readSourceLocation()); |
987 | for (unsigned I = 0; I < NumIters; ++I) { |
988 | E->setIteratorDeclaration(I, Record.readDeclRef()); |
989 | E->setAssignmentLoc(I, readSourceLocation()); |
990 | Expr *Begin = Record.readSubExpr(); |
991 | Expr *End = Record.readSubExpr(); |
992 | Expr *Step = Record.readSubExpr(); |
993 | SourceLocation ColonLoc = readSourceLocation(); |
994 | SourceLocation SecColonLoc; |
995 | if (Step) |
996 | SecColonLoc = readSourceLocation(); |
997 | E->setIteratorRange(I, Begin, ColonLoc, End, SecColonLoc, Step); |
998 | |
999 | OMPIteratorHelperData HD; |
1000 | HD.CounterVD = cast_or_null<VarDecl>(Record.readDeclRef()); |
1001 | HD.Upper = Record.readSubExpr(); |
1002 | HD.Update = Record.readSubExpr(); |
1003 | HD.CounterUpdate = Record.readSubExpr(); |
1004 | E->setHelper(I, HD); |
1005 | } |
1006 | } |
1007 | |
1008 | void ASTStmtReader::VisitCallExpr(CallExpr *E) { |
1009 | VisitExpr(E); |
1010 | unsigned NumArgs = Record.readInt(); |
1011 | bool HasFPFeatures = Record.readInt(); |
1012 | assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!"); |
1013 | E->setRParenLoc(readSourceLocation()); |
1014 | E->setCallee(Record.readSubExpr()); |
1015 | for (unsigned I = 0; I != NumArgs; ++I) |
1016 | E->setArg(I, Record.readSubExpr()); |
1017 | E->setADLCallKind(static_cast<CallExpr::ADLCallKind>(Record.readInt())); |
1018 | if (HasFPFeatures) |
1019 | E->setStoredFPFeatures( |
1020 | FPOptionsOverride::getFromOpaqueInt(Record.readInt())); |
1021 | } |
1022 | |
1023 | void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { |
1024 | VisitCallExpr(E); |
1025 | } |
1026 | |
1027 | void ASTStmtReader::VisitMemberExpr(MemberExpr *E) { |
1028 | VisitExpr(E); |
1029 | |
1030 | bool HasQualifier = Record.readInt(); |
1031 | bool HasFoundDecl = Record.readInt(); |
1032 | bool HasTemplateInfo = Record.readInt(); |
1033 | unsigned NumTemplateArgs = Record.readInt(); |
1034 | |
1035 | E->Base = Record.readSubExpr(); |
1036 | E->MemberDecl = Record.readDeclAs<ValueDecl>(); |
1037 | E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName()); |
1038 | E->MemberLoc = Record.readSourceLocation(); |
1039 | E->MemberExprBits.IsArrow = Record.readInt(); |
1040 | E->MemberExprBits.HasQualifierOrFoundDecl = HasQualifier || HasFoundDecl; |
1041 | E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo; |
1042 | E->MemberExprBits.HadMultipleCandidates = Record.readInt(); |
1043 | E->MemberExprBits.NonOdrUseReason = Record.readInt(); |
1044 | E->MemberExprBits.OperatorLoc = Record.readSourceLocation(); |
1045 | |
1046 | if (HasQualifier || HasFoundDecl) { |
1047 | DeclAccessPair FoundDecl; |
1048 | if (HasFoundDecl) { |
1049 | auto *FoundD = Record.readDeclAs<NamedDecl>(); |
1050 | auto AS = (AccessSpecifier)Record.readInt(); |
1051 | FoundDecl = DeclAccessPair::make(FoundD, AS); |
1052 | } else { |
1053 | FoundDecl = DeclAccessPair::make(E->MemberDecl, |
1054 | E->MemberDecl->getAccess()); |
1055 | } |
1056 | E->getTrailingObjects<MemberExprNameQualifier>()->FoundDecl = FoundDecl; |
1057 | |
1058 | NestedNameSpecifierLoc QualifierLoc; |
1059 | if (HasQualifier) |
1060 | QualifierLoc = Record.readNestedNameSpecifierLoc(); |
1061 | E->getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc = |
1062 | QualifierLoc; |
1063 | } |
1064 | |
1065 | if (HasTemplateInfo) |
1066 | ReadTemplateKWAndArgsInfo( |
1067 | *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), |
1068 | E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); |
1069 | } |
1070 | |
1071 | void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) { |
1072 | VisitExpr(E); |
1073 | E->setBase(Record.readSubExpr()); |
1074 | E->setIsaMemberLoc(readSourceLocation()); |
1075 | E->setOpLoc(readSourceLocation()); |
1076 | E->setArrow(Record.readInt()); |
1077 | } |
1078 | |
1079 | void ASTStmtReader:: |
1080 | VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { |
1081 | VisitExpr(E); |
1082 | E->Operand = Record.readSubExpr(); |
1083 | E->setShouldCopy(Record.readInt()); |
1084 | } |
1085 | |
1086 | void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { |
1087 | VisitExplicitCastExpr(E); |
1088 | E->LParenLoc = readSourceLocation(); |
1089 | E->BridgeKeywordLoc = readSourceLocation(); |
1090 | E->Kind = Record.readInt(); |
1091 | } |
1092 | |
1093 | void ASTStmtReader::VisitCastExpr(CastExpr *E) { |
1094 | VisitExpr(E); |
1095 | unsigned NumBaseSpecs = Record.readInt(); |
1096 | assert(NumBaseSpecs == E->path_size()); |
1097 | unsigned HasFPFeatures = Record.readInt(); |
1098 | assert(E->hasStoredFPFeatures() == HasFPFeatures); |
1099 | E->setSubExpr(Record.readSubExpr()); |
1100 | E->setCastKind((CastKind)Record.readInt()); |
1101 | CastExpr::path_iterator BaseI = E->path_begin(); |
1102 | while (NumBaseSpecs--) { |
1103 | auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier; |
1104 | *BaseSpec = Record.readCXXBaseSpecifier(); |
1105 | *BaseI++ = BaseSpec; |
1106 | } |
1107 | if (HasFPFeatures) |
1108 | *E->getTrailingFPFeatures() = |
1109 | FPOptionsOverride::getFromOpaqueInt(Record.readInt()); |
1110 | } |
1111 | |
1112 | void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) { |
1113 | bool hasFP_Features; |
1114 | VisitExpr(E); |
1115 | E->setHasStoredFPFeatures(hasFP_Features = Record.readInt()); |
1116 | E->setOpcode((BinaryOperator::Opcode)Record.readInt()); |
1117 | E->setLHS(Record.readSubExpr()); |
1118 | E->setRHS(Record.readSubExpr()); |
1119 | E->setOperatorLoc(readSourceLocation()); |
1120 | if (hasFP_Features) |
1121 | E->setStoredFPFeatures( |
1122 | FPOptionsOverride::getFromOpaqueInt(Record.readInt())); |
1123 | } |
1124 | |
1125 | void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) { |
1126 | VisitBinaryOperator(E); |
1127 | E->setComputationLHSType(Record.readType()); |
1128 | E->setComputationResultType(Record.readType()); |
1129 | } |
1130 | |
1131 | void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) { |
1132 | VisitExpr(E); |
1133 | E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr(); |
1134 | E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr(); |
1135 | E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr(); |
1136 | E->QuestionLoc = readSourceLocation(); |
1137 | E->ColonLoc = readSourceLocation(); |
1138 | } |
1139 | |
1140 | void |
1141 | ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { |
1142 | VisitExpr(E); |
1143 | E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr()); |
1144 | E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr(); |
1145 | E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr(); |
1146 | E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr(); |
1147 | E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr(); |
1148 | E->QuestionLoc = readSourceLocation(); |
1149 | E->ColonLoc = readSourceLocation(); |
1150 | } |
1151 | |
1152 | void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) { |
1153 | VisitCastExpr(E); |
1154 | E->setIsPartOfExplicitCast(Record.readInt()); |
1155 | } |
1156 | |
1157 | void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) { |
1158 | VisitCastExpr(E); |
1159 | E->setTypeInfoAsWritten(readTypeSourceInfo()); |
1160 | } |
1161 | |
1162 | void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) { |
1163 | VisitExplicitCastExpr(E); |
1164 | E->setLParenLoc(readSourceLocation()); |
1165 | E->setRParenLoc(readSourceLocation()); |
1166 | } |
1167 | |
1168 | void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { |
1169 | VisitExpr(E); |
1170 | E->setLParenLoc(readSourceLocation()); |
1171 | E->setTypeSourceInfo(readTypeSourceInfo()); |
1172 | E->setInitializer(Record.readSubExpr()); |
1173 | E->setFileScope(Record.readInt()); |
1174 | } |
1175 | |
1176 | void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { |
1177 | VisitExpr(E); |
1178 | E->setBase(Record.readSubExpr()); |
1179 | E->setAccessor(Record.readIdentifier()); |
1180 | E->setAccessorLoc(readSourceLocation()); |
1181 | } |
1182 | |
1183 | void ASTStmtReader::VisitInitListExpr(InitListExpr *E) { |
1184 | VisitExpr(E); |
1185 | if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt())) |
1186 | E->setSyntacticForm(SyntForm); |
1187 | E->setLBraceLoc(readSourceLocation()); |
1188 | E->setRBraceLoc(readSourceLocation()); |
1189 | bool isArrayFiller = Record.readInt(); |
1190 | Expr *filler = nullptr; |
1191 | if (isArrayFiller) { |
1192 | filler = Record.readSubExpr(); |
1193 | E->ArrayFillerOrUnionFieldInit = filler; |
1194 | } else |
1195 | E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>(); |
1196 | E->sawArrayRangeDesignator(Record.readInt()); |
1197 | unsigned NumInits = Record.readInt(); |
1198 | E->reserveInits(Record.getContext(), NumInits); |
1199 | if (isArrayFiller) { |
1200 | for (unsigned I = 0; I != NumInits; ++I) { |
1201 | Expr *init = Record.readSubExpr(); |
1202 | E->updateInit(Record.getContext(), I, init ? init : filler); |
1203 | } |
1204 | } else { |
1205 | for (unsigned I = 0; I != NumInits; ++I) |
1206 | E->updateInit(Record.getContext(), I, Record.readSubExpr()); |
1207 | } |
1208 | } |
1209 | |
1210 | void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { |
1211 | using Designator = DesignatedInitExpr::Designator; |
1212 | |
1213 | VisitExpr(E); |
1214 | unsigned NumSubExprs = Record.readInt(); |
1215 | assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs"); |
1216 | for (unsigned I = 0; I != NumSubExprs; ++I) |
1217 | E->setSubExpr(I, Record.readSubExpr()); |
1218 | E->setEqualOrColonLoc(readSourceLocation()); |
1219 | E->setGNUSyntax(Record.readInt()); |
1220 | |
1221 | SmallVector<Designator, 4> Designators; |
1222 | while (Record.getIdx() < Record.size()) { |
1223 | switch ((DesignatorTypes)Record.readInt()) { |
1224 | case DESIG_FIELD_DECL: { |
1225 | auto *Field = readDeclAs<FieldDecl>(); |
1226 | SourceLocation DotLoc = readSourceLocation(); |
1227 | SourceLocation FieldLoc = readSourceLocation(); |
1228 | Designators.push_back(Designator(Field->getIdentifier(), DotLoc, |
1229 | FieldLoc)); |
1230 | Designators.back().setField(Field); |
1231 | break; |
1232 | } |
1233 | |
1234 | case DESIG_FIELD_NAME: { |
1235 | const IdentifierInfo *Name = Record.readIdentifier(); |
1236 | SourceLocation DotLoc = readSourceLocation(); |
1237 | SourceLocation FieldLoc = readSourceLocation(); |
1238 | Designators.push_back(Designator(Name, DotLoc, FieldLoc)); |
1239 | break; |
1240 | } |
1241 | |
1242 | case DESIG_ARRAY: { |
1243 | unsigned Index = Record.readInt(); |
1244 | SourceLocation LBracketLoc = readSourceLocation(); |
1245 | SourceLocation RBracketLoc = readSourceLocation(); |
1246 | Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc)); |
1247 | break; |
1248 | } |
1249 | |
1250 | case DESIG_ARRAY_RANGE: { |
1251 | unsigned Index = Record.readInt(); |
1252 | SourceLocation LBracketLoc = readSourceLocation(); |
1253 | SourceLocation EllipsisLoc = readSourceLocation(); |
1254 | SourceLocation RBracketLoc = readSourceLocation(); |
1255 | Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc, |
1256 | RBracketLoc)); |
1257 | break; |
1258 | } |
1259 | } |
1260 | } |
1261 | E->setDesignators(Record.getContext(), |
1262 | Designators.data(), Designators.size()); |
1263 | } |
1264 | |
1265 | void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { |
1266 | VisitExpr(E); |
1267 | E->setBase(Record.readSubExpr()); |
1268 | E->setUpdater(Record.readSubExpr()); |
1269 | } |
1270 | |
1271 | void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) { |
1272 | VisitExpr(E); |
1273 | } |
1274 | |
1275 | void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { |
1276 | VisitExpr(E); |
1277 | E->SubExprs[0] = Record.readSubExpr(); |
1278 | E->SubExprs[1] = Record.readSubExpr(); |
1279 | } |
1280 | |
1281 | void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { |
1282 | VisitExpr(E); |
1283 | } |
1284 | |
1285 | void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { |
1286 | VisitExpr(E); |
1287 | } |
1288 | |
1289 | void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) { |
1290 | VisitExpr(E); |
1291 | E->setSubExpr(Record.readSubExpr()); |
1292 | E->setWrittenTypeInfo(readTypeSourceInfo()); |
1293 | E->setBuiltinLoc(readSourceLocation()); |
1294 | E->setRParenLoc(readSourceLocation()); |
1295 | E->setIsMicrosoftABI(Record.readInt()); |
1296 | } |
1297 | |
1298 | void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) { |
1299 | VisitExpr(E); |
1300 | E->ParentContext = readDeclAs<DeclContext>(); |
1301 | E->BuiltinLoc = readSourceLocation(); |
1302 | E->RParenLoc = readSourceLocation(); |
1303 | E->SourceLocExprBits.Kind = |
1304 | static_cast<SourceLocExpr::IdentKind>(Record.readInt()); |
1305 | } |
1306 | |
1307 | void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) { |
1308 | VisitExpr(E); |
1309 | E->setAmpAmpLoc(readSourceLocation()); |
1310 | E->setLabelLoc(readSourceLocation()); |
1311 | E->setLabel(readDeclAs<LabelDecl>()); |
1312 | } |
1313 | |
1314 | void ASTStmtReader::VisitStmtExpr(StmtExpr *E) { |
1315 | VisitExpr(E); |
1316 | E->setLParenLoc(readSourceLocation()); |
1317 | E->setRParenLoc(readSourceLocation()); |
1318 | E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt())); |
1319 | E->StmtExprBits.TemplateDepth = Record.readInt(); |
1320 | } |
1321 | |
1322 | void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) { |
1323 | VisitExpr(E); |
1324 | E->setCond(Record.readSubExpr()); |
1325 | E->setLHS(Record.readSubExpr()); |
1326 | E->setRHS(Record.readSubExpr()); |
1327 | E->setBuiltinLoc(readSourceLocation()); |
1328 | E->setRParenLoc(readSourceLocation()); |
1329 | E->setIsConditionTrue(Record.readInt()); |
1330 | } |
1331 | |
1332 | void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) { |
1333 | VisitExpr(E); |
1334 | E->setTokenLocation(readSourceLocation()); |
1335 | } |
1336 | |
1337 | void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { |
1338 | VisitExpr(E); |
1339 | SmallVector<Expr *, 16> Exprs; |
1340 | unsigned NumExprs = Record.readInt(); |
1341 | while (NumExprs--) |
1342 | Exprs.push_back(Record.readSubExpr()); |
1343 | E->setExprs(Record.getContext(), Exprs); |
1344 | E->setBuiltinLoc(readSourceLocation()); |
1345 | E->setRParenLoc(readSourceLocation()); |
1346 | } |
1347 | |
1348 | void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) { |
1349 | VisitExpr(E); |
1350 | E->BuiltinLoc = readSourceLocation(); |
1351 | E->RParenLoc = readSourceLocation(); |
1352 | E->TInfo = readTypeSourceInfo(); |
1353 | E->SrcExpr = Record.readSubExpr(); |
1354 | } |
1355 | |
1356 | void ASTStmtReader::VisitBlockExpr(BlockExpr *E) { |
1357 | VisitExpr(E); |
1358 | E->setBlockDecl(readDeclAs<BlockDecl>()); |
1359 | } |
1360 | |
1361 | void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) { |
1362 | VisitExpr(E); |
1363 | |
1364 | unsigned NumAssocs = Record.readInt(); |
1365 | assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!"); |
1366 | E->ResultIndex = Record.readInt(); |
1367 | E->GenericSelectionExprBits.GenericLoc = readSourceLocation(); |
1368 | E->DefaultLoc = readSourceLocation(); |
1369 | E->RParenLoc = readSourceLocation(); |
1370 | |
1371 | Stmt **Stmts = E->getTrailingObjects<Stmt *>(); |
1372 | |
1373 | |
1374 | |
1375 | for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I) |
1376 | Stmts[I] = Record.readSubExpr(); |
1377 | |
1378 | TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>(); |
1379 | for (unsigned I = 0, N = NumAssocs; I < N; ++I) |
1380 | TSIs[I] = readTypeSourceInfo(); |
1381 | } |
1382 | |
1383 | void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) { |
1384 | VisitExpr(E); |
1385 | unsigned numSemanticExprs = Record.readInt(); |
1386 | assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs); |
1387 | E->PseudoObjectExprBits.ResultIndex = Record.readInt(); |
1388 | |
1389 | |
1390 | E->getSubExprsBuffer()[0] = Record.readSubExpr(); |
1391 | |
1392 | |
1393 | for (unsigned i = 0; i != numSemanticExprs; ++i) { |
1394 | Expr *subExpr = Record.readSubExpr(); |
1395 | E->getSubExprsBuffer()[i+1] = subExpr; |
1396 | } |
1397 | } |
1398 | |
1399 | void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) { |
1400 | VisitExpr(E); |
1401 | E->Op = AtomicExpr::AtomicOp(Record.readInt()); |
1402 | E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op); |
1403 | for (unsigned I = 0; I != E->NumSubExprs; ++I) |
1404 | E->SubExprs[I] = Record.readSubExpr(); |
1405 | E->BuiltinLoc = readSourceLocation(); |
1406 | E->RParenLoc = readSourceLocation(); |
1407 | } |
1408 | |
1409 | |
1410 | |
1411 | |
1412 | void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) { |
1413 | VisitExpr(E); |
1414 | E->setString(cast<StringLiteral>(Record.readSubStmt())); |
1415 | E->setAtLoc(readSourceLocation()); |
1416 | } |
1417 | |
1418 | void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { |
1419 | VisitExpr(E); |
1420 | |
1421 | E->SubExpr = Record.readSubStmt(); |
1422 | E->BoxingMethod = readDeclAs<ObjCMethodDecl>(); |
1423 | E->Range = readSourceRange(); |
1424 | } |
1425 | |
1426 | void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { |
1427 | VisitExpr(E); |
1428 | unsigned NumElements = Record.readInt(); |
1429 | assert(NumElements == E->getNumElements() && "Wrong number of elements"); |
1430 | Expr **Elements = E->getElements(); |
1431 | for (unsigned I = 0, N = NumElements; I != N; ++I) |
1432 | Elements[I] = Record.readSubExpr(); |
1433 | E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>(); |
1434 | E->Range = readSourceRange(); |
1435 | } |
1436 | |
1437 | void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { |
1438 | VisitExpr(E); |
1439 | unsigned NumElements = Record.readInt(); |
1440 | assert(NumElements == E->getNumElements() && "Wrong number of elements"); |
1441 | bool HasPackExpansions = Record.readInt(); |
1442 | assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch"); |
1443 | auto *KeyValues = |
1444 | E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>(); |
1445 | auto *Expansions = |
1446 | E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>(); |
1447 | for (unsigned I = 0; I != NumElements; ++I) { |
1448 | KeyValues[I].Key = Record.readSubExpr(); |
1449 | KeyValues[I].Value = Record.readSubExpr(); |
1450 | if (HasPackExpansions) { |
1451 | Expansions[I].EllipsisLoc = readSourceLocation(); |
1452 | Expansions[I].NumExpansionsPlusOne = Record.readInt(); |
1453 | } |
1454 | } |
1455 | E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>(); |
1456 | E->Range = readSourceRange(); |
1457 | } |
1458 | |
1459 | void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { |
1460 | VisitExpr(E); |
1461 | E->setEncodedTypeSourceInfo(readTypeSourceInfo()); |
1462 | E->setAtLoc(readSourceLocation()); |
1463 | E->setRParenLoc(readSourceLocation()); |
1464 | } |
1465 | |
1466 | void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { |
1467 | VisitExpr(E); |
1468 | E->setSelector(Record.readSelector()); |
1469 | E->setAtLoc(readSourceLocation()); |
1470 | E->setRParenLoc(readSourceLocation()); |
1471 | } |
1472 | |
1473 | void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { |
1474 | VisitExpr(E); |
1475 | E->setProtocol(readDeclAs<ObjCProtocolDecl>()); |
1476 | E->setAtLoc(readSourceLocation()); |
1477 | E->ProtoLoc = readSourceLocation(); |
1478 | E->setRParenLoc(readSourceLocation()); |
1479 | } |
1480 | |
1481 | void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { |
1482 | VisitExpr(E); |
1483 | E->setDecl(readDeclAs<ObjCIvarDecl>()); |
1484 | E->setLocation(readSourceLocation()); |
1485 | E->setOpLoc(readSourceLocation()); |
1486 | E->setBase(Record.readSubExpr()); |
1487 | E->setIsArrow(Record.readInt()); |
1488 | E->setIsFreeIvar(Record.readInt()); |
1489 | } |
1490 | |
1491 | void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { |
1492 | VisitExpr(E); |
1493 | unsigned MethodRefFlags = Record.readInt(); |
1494 | bool Implicit = Record.readInt() != 0; |
1495 | if (Implicit) { |
1496 | auto *Getter = readDeclAs<ObjCMethodDecl>(); |
1497 | auto *Setter = readDeclAs<ObjCMethodDecl>(); |
1498 | E->setImplicitProperty(Getter, Setter, MethodRefFlags); |
1499 | } else { |
1500 | E->setExplicitProperty(readDeclAs<ObjCPropertyDecl>(), MethodRefFlags); |
1501 | } |
1502 | E->setLocation(readSourceLocation()); |
1503 | E->setReceiverLocation(readSourceLocation()); |
1504 | switch (Record.readInt()) { |
1505 | case 0: |
1506 | E->setBase(Record.readSubExpr()); |
1507 | break; |
1508 | case 1: |
1509 | E->setSuperReceiver(Record.readType()); |
1510 | break; |
1511 | case 2: |
1512 | E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>()); |
1513 | break; |
1514 | } |
1515 | } |
1516 | |
1517 | void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { |
1518 | VisitExpr(E); |
1519 | E->setRBracket(readSourceLocation()); |
1520 | E->setBaseExpr(Record.readSubExpr()); |
1521 | E->setKeyExpr(Record.readSubExpr()); |
1522 | E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>(); |
1523 | E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>(); |
1524 | } |
1525 | |
1526 | void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { |
1527 | VisitExpr(E); |
1528 | assert(Record.peekInt() == E->getNumArgs()); |
1529 | Record.skipInts(1); |
1530 | unsigned NumStoredSelLocs = Record.readInt(); |
1531 | E->SelLocsKind = Record.readInt(); |
1532 | E->setDelegateInitCall(Record.readInt()); |
1533 | E->IsImplicit = Record.readInt(); |
1534 | auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt()); |
1535 | switch (Kind) { |
1536 | case ObjCMessageExpr::Instance: |
1537 | E->setInstanceReceiver(Record.readSubExpr()); |
1538 | break; |
1539 | |
1540 | case ObjCMessageExpr::Class: |
1541 | E->setClassReceiver(readTypeSourceInfo()); |
1542 | break; |
1543 | |
1544 | case ObjCMessageExpr::SuperClass: |
1545 | case ObjCMessageExpr::SuperInstance: { |
1546 | QualType T = Record.readType(); |
1547 | SourceLocation SuperLoc = readSourceLocation(); |
1548 | E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance); |
1549 | break; |
1550 | } |
1551 | } |
1552 | |
1553 | assert(Kind == E->getReceiverKind()); |
1554 | |
1555 | if (Record.readInt()) |
1556 | E->setMethodDecl(readDeclAs<ObjCMethodDecl>()); |
1557 | else |
1558 | E->setSelector(Record.readSelector()); |
1559 | |
1560 | E->LBracLoc = readSourceLocation(); |
1561 | E->RBracLoc = readSourceLocation(); |
1562 | |
1563 | for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) |
1564 | E->setArg(I, Record.readSubExpr()); |
1565 | |
1566 | SourceLocation *Locs = E->getStoredSelLocs(); |
1567 | for (unsigned I = 0; I != NumStoredSelLocs; ++I) |
1568 | Locs[I] = readSourceLocation(); |
1569 | } |
1570 | |
1571 | void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { |
1572 | VisitStmt(S); |
1573 | S->setElement(Record.readSubStmt()); |
1574 | S->setCollection(Record.readSubExpr()); |
1575 | S->setBody(Record.readSubStmt()); |
1576 | S->setForLoc(readSourceLocation()); |
1577 | S->setRParenLoc(readSourceLocation()); |
1578 | } |
1579 | |
1580 | void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { |
1581 | VisitStmt(S); |
1582 | S->setCatchBody(Record.readSubStmt()); |
1583 | S->setCatchParamDecl(readDeclAs<VarDecl>()); |
1584 | S->setAtCatchLoc(readSourceLocation()); |
1585 | S->setRParenLoc(readSourceLocation()); |
1586 | } |
1587 | |
1588 | void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { |
1589 | VisitStmt(S); |
1590 | S->setFinallyBody(Record.readSubStmt()); |
1591 | S->setAtFinallyLoc(readSourceLocation()); |
1592 | } |
1593 | |
1594 | void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { |
1595 | VisitStmt(S); |
1596 | S->setSubStmt(Record.readSubStmt()); |
1597 | S->setAtLoc(readSourceLocation()); |
1598 | } |
1599 | |
1600 | void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { |
1601 | VisitStmt(S); |
1602 | assert(Record.peekInt() == S->getNumCatchStmts()); |
1603 | Record.skipInts(1); |
1604 | bool HasFinally = Record.readInt(); |
1605 | S->setTryBody(Record.readSubStmt()); |
1606 | for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) |
1607 | S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt())); |
1608 | |
1609 | if (HasFinally) |
1610 | S->setFinallyStmt(Record.readSubStmt()); |
1611 | S->setAtTryLoc(readSourceLocation()); |
1612 | } |
1613 | |
1614 | void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { |
1615 | VisitStmt(S); |
1616 | S->setSynchExpr(Record.readSubStmt()); |
1617 | S->setSynchBody(Record.readSubStmt()); |
1618 | S->setAtSynchronizedLoc(readSourceLocation()); |
1619 | } |
1620 | |
1621 | void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { |
1622 | VisitStmt(S); |
1623 | S->setThrowExpr(Record.readSubStmt()); |
1624 | S->setThrowLoc(readSourceLocation()); |
1625 | } |
1626 | |
1627 | void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { |
1628 | VisitExpr(E); |
1629 | E->setValue(Record.readInt()); |
1630 | E->setLocation(readSourceLocation()); |
1631 | } |
1632 | |
1633 | void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) { |
1634 | VisitExpr(E); |
1635 | SourceRange R = Record.readSourceRange(); |
1636 | E->AtLoc = R.getBegin(); |
1637 | E->RParen = R.getEnd(); |
1638 | E->VersionToCheck = Record.readVersionTuple(); |
1639 | } |
1640 | |
1641 | |
1642 | |
1643 | |
1644 | |
1645 | void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) { |
1646 | VisitStmt(S); |
1647 | S->CatchLoc = readSourceLocation(); |
1648 | S->ExceptionDecl = readDeclAs<VarDecl>(); |
1649 | S->HandlerBlock = Record.readSubStmt(); |
1650 | } |
1651 | |
1652 | void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) { |
1653 | VisitStmt(S); |
1654 | assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?"); |
1655 | Record.skipInts(1); |
1656 | S->TryLoc = readSourceLocation(); |
1657 | S->getStmts()[0] = Record.readSubStmt(); |
1658 | for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) |
1659 | S->getStmts()[i + 1] = Record.readSubStmt(); |
1660 | } |
1661 | |
1662 | void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) { |
1663 | VisitStmt(S); |
1664 | S->ForLoc = readSourceLocation(); |
1665 | S->CoawaitLoc = readSourceLocation(); |
1666 | S->ColonLoc = readSourceLocation(); |
1667 | S->RParenLoc = readSourceLocation(); |
1668 | S->setInit(Record.readSubStmt()); |
1669 | S->setRangeStmt(Record.readSubStmt()); |
1670 | S->setBeginStmt(Record.readSubStmt()); |
1671 | S->setEndStmt(Record.readSubStmt()); |
1672 | S->setCond(Record.readSubExpr()); |
1673 | S->setInc(Record.readSubExpr()); |
1674 | S->setLoopVarStmt(Record.readSubStmt()); |
1675 | S->setBody(Record.readSubStmt()); |
1676 | } |
1677 | |
1678 | void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { |
1679 | VisitStmt(S); |
1680 | S->KeywordLoc = readSourceLocation(); |
1681 | S->IsIfExists = Record.readInt(); |
1682 | S->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
1683 | S->NameInfo = Record.readDeclarationNameInfo(); |
1684 | S->SubStmt = Record.readSubStmt(); |
1685 | } |
1686 | |
1687 | void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { |
1688 | VisitCallExpr(E); |
1689 | E->CXXOperatorCallExprBits.OperatorKind = Record.readInt(); |
1690 | E->Range = Record.readSourceRange(); |
1691 | } |
1692 | |
1693 | void ASTStmtReader::VisitCXXRewrittenBinaryOperator( |
1694 | CXXRewrittenBinaryOperator *E) { |
1695 | VisitExpr(E); |
1696 | E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt(); |
1697 | E->SemanticForm = Record.readSubExpr(); |
1698 | } |
1699 | |
1700 | void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { |
1701 | VisitExpr(E); |
1702 | |
1703 | unsigned NumArgs = Record.readInt(); |
1704 | assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!"); |
1705 | |
1706 | E->CXXConstructExprBits.Elidable = Record.readInt(); |
1707 | E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt(); |
1708 | E->CXXConstructExprBits.ListInitialization = Record.readInt(); |
1709 | E->CXXConstructExprBits.StdInitListInitialization = Record.readInt(); |
1710 | E->CXXConstructExprBits.ZeroInitialization = Record.readInt(); |
1711 | E->CXXConstructExprBits.ConstructionKind = Record.readInt(); |
1712 | E->CXXConstructExprBits.Loc = readSourceLocation(); |
1713 | E->Constructor = readDeclAs<CXXConstructorDecl>(); |
1714 | E->ParenOrBraceRange = readSourceRange(); |
1715 | |
1716 | for (unsigned I = 0; I != NumArgs; ++I) |
1717 | E->setArg(I, Record.readSubExpr()); |
1718 | } |
1719 | |
1720 | void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { |
1721 | VisitExpr(E); |
1722 | E->Constructor = readDeclAs<CXXConstructorDecl>(); |
1723 | E->Loc = readSourceLocation(); |
1724 | E->ConstructsVirtualBase = Record.readInt(); |
1725 | E->InheritedFromVirtualBase = Record.readInt(); |
1726 | } |
1727 | |
1728 | void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { |
1729 | VisitCXXConstructExpr(E); |
1730 | E->TSI = readTypeSourceInfo(); |
1731 | } |
1732 | |
1733 | void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) { |
1734 | VisitExpr(E); |
1735 | unsigned NumCaptures = Record.readInt(); |
1736 | (void)NumCaptures; |
1737 | assert(NumCaptures == E->LambdaExprBits.NumCaptures); |
1738 | E->IntroducerRange = readSourceRange(); |
1739 | E->LambdaExprBits.CaptureDefault = Record.readInt(); |
1740 | E->CaptureDefaultLoc = readSourceLocation(); |
1741 | E->LambdaExprBits.ExplicitParams = Record.readInt(); |
1742 | E->LambdaExprBits.ExplicitResultType = Record.readInt(); |
1743 | E->ClosingBrace = readSourceLocation(); |
1744 | |
1745 | |
1746 | for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), |
1747 | CEnd = E->capture_init_end(); |
1748 | C != CEnd; ++C) |
1749 | *C = Record.readSubExpr(); |
1750 | |
1751 | |
1752 | |
1753 | } |
1754 | |
1755 | void |
1756 | ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { |
1757 | VisitExpr(E); |
1758 | E->SubExpr = Record.readSubExpr(); |
1759 | } |
1760 | |
1761 | void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { |
1762 | VisitExplicitCastExpr(E); |
1763 | SourceRange R = readSourceRange(); |
1764 | E->Loc = R.getBegin(); |
1765 | E->RParenLoc = R.getEnd(); |
1766 | R = readSourceRange(); |
1767 | E->AngleBrackets = R; |
1768 | } |
1769 | |
1770 | void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { |
1771 | return VisitCXXNamedCastExpr(E); |
1772 | } |
1773 | |
1774 | void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { |
1775 | return VisitCXXNamedCastExpr(E); |
1776 | } |
1777 | |
1778 | void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { |
1779 | return VisitCXXNamedCastExpr(E); |
1780 | } |
1781 | |
1782 | void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) { |
1783 | return VisitCXXNamedCastExpr(E); |
1784 | } |
1785 | |
1786 | void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) { |
1787 | return VisitCXXNamedCastExpr(E); |
1788 | } |
1789 | |
1790 | void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { |
1791 | VisitExplicitCastExpr(E); |
1792 | E->setLParenLoc(readSourceLocation()); |
1793 | E->setRParenLoc(readSourceLocation()); |
1794 | } |
1795 | |
1796 | void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) { |
1797 | VisitExplicitCastExpr(E); |
1798 | E->KWLoc = readSourceLocation(); |
1799 | E->RParenLoc = readSourceLocation(); |
1800 | } |
1801 | |
1802 | void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) { |
1803 | VisitCallExpr(E); |
1804 | E->UDSuffixLoc = readSourceLocation(); |
1805 | } |
1806 | |
1807 | void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { |
1808 | VisitExpr(E); |
1809 | E->setValue(Record.readInt()); |
1810 | E->setLocation(readSourceLocation()); |
1811 | } |
1812 | |
1813 | void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { |
1814 | VisitExpr(E); |
1815 | E->setLocation(readSourceLocation()); |
1816 | } |
1817 | |
1818 | void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) { |
1819 | VisitExpr(E); |
1820 | E->setSourceRange(readSourceRange()); |
1821 | if (E->isTypeOperand()) |
1822 | E->Operand = readTypeSourceInfo(); |
1823 | else |
1824 | E->Operand = Record.readSubExpr(); |
1825 | } |
1826 | |
1827 | void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) { |
1828 | VisitExpr(E); |
1829 | E->setLocation(readSourceLocation()); |
1830 | E->setImplicit(Record.readInt()); |
1831 | } |
1832 | |
1833 | void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) { |
1834 | VisitExpr(E); |
1835 | E->CXXThrowExprBits.ThrowLoc = readSourceLocation(); |
1836 | E->Operand = Record.readSubExpr(); |
1837 | E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt(); |
1838 | } |
1839 | |
1840 | void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { |
1841 | VisitExpr(E); |
1842 | E->Param = readDeclAs<ParmVarDecl>(); |
1843 | E->UsedContext = readDeclAs<DeclContext>(); |
1844 | E->CXXDefaultArgExprBits.Loc = readSourceLocation(); |
1845 | } |
1846 | |
1847 | void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { |
1848 | VisitExpr(E); |
1849 | E->Field = readDeclAs<FieldDecl>(); |
1850 | E->UsedContext = readDeclAs<DeclContext>(); |
1851 | E->CXXDefaultInitExprBits.Loc = readSourceLocation(); |
1852 | } |
1853 | |
1854 | void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { |
1855 | VisitExpr(E); |
1856 | E->setTemporary(Record.readCXXTemporary()); |
1857 | E->setSubExpr(Record.readSubExpr()); |
1858 | } |
1859 | |
1860 | void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { |
1861 | VisitExpr(E); |
1862 | E->TypeInfo = readTypeSourceInfo(); |
1863 | E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation(); |
1864 | } |
1865 | |
1866 | void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { |
1867 | VisitExpr(E); |
1868 | |
1869 | bool IsArray = Record.readInt(); |
1870 | bool HasInit = Record.readInt(); |
1871 | unsigned NumPlacementArgs = Record.readInt(); |
1872 | bool IsParenTypeId = Record.readInt(); |
1873 | |
1874 | E->CXXNewExprBits.IsGlobalNew = Record.readInt(); |
1875 | E->CXXNewExprBits.ShouldPassAlignment = Record.readInt(); |
1876 | E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt(); |
1877 | E->CXXNewExprBits.StoredInitializationStyle = Record.readInt(); |
1878 | |
1879 | assert((IsArray == E->isArray()) && "Wrong IsArray!"); |
1880 | assert((HasInit == E->hasInitializer()) && "Wrong HasInit!"); |
1881 | assert((NumPlacementArgs == E->getNumPlacementArgs()) && |
1882 | "Wrong NumPlacementArgs!"); |
1883 | assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!"); |
1884 | (void)IsArray; |
1885 | (void)HasInit; |
1886 | (void)NumPlacementArgs; |
1887 | |
1888 | E->setOperatorNew(readDeclAs<FunctionDecl>()); |
1889 | E->setOperatorDelete(readDeclAs<FunctionDecl>()); |
1890 | E->AllocatedTypeInfo = readTypeSourceInfo(); |
1891 | if (IsParenTypeId) |
1892 | E->getTrailingObjects<SourceRange>()[0] = readSourceRange(); |
1893 | E->Range = readSourceRange(); |
1894 | E->DirectInitRange = readSourceRange(); |
1895 | |
1896 | |
1897 | for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(), |
1898 | N = E->raw_arg_end(); |
1899 | I != N; ++I) |
1900 | *I = Record.readSubStmt(); |
1901 | } |
1902 | |
1903 | void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { |
1904 | VisitExpr(E); |
1905 | E->CXXDeleteExprBits.GlobalDelete = Record.readInt(); |
1906 | E->CXXDeleteExprBits.ArrayForm = Record.readInt(); |
1907 | E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt(); |
1908 | E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt(); |
1909 | E->OperatorDelete = readDeclAs<FunctionDecl>(); |
1910 | E->Argument = Record.readSubExpr(); |
1911 | E->CXXDeleteExprBits.Loc = readSourceLocation(); |
1912 | } |
1913 | |
1914 | void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { |
1915 | VisitExpr(E); |
1916 | |
1917 | E->Base = Record.readSubExpr(); |
1918 | E->IsArrow = Record.readInt(); |
1919 | E->OperatorLoc = readSourceLocation(); |
1920 | E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
1921 | E->ScopeType = readTypeSourceInfo(); |
1922 | E->ColonColonLoc = readSourceLocation(); |
1923 | E->TildeLoc = readSourceLocation(); |
1924 | |
1925 | IdentifierInfo *II = Record.readIdentifier(); |
1926 | if (II) |
1927 | E->setDestroyedType(II, readSourceLocation()); |
1928 | else |
1929 | E->setDestroyedType(readTypeSourceInfo()); |
1930 | } |
1931 | |
1932 | void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) { |
1933 | VisitExpr(E); |
1934 | |
1935 | unsigned NumObjects = Record.readInt(); |
1936 | assert(NumObjects == E->getNumObjects()); |
1937 | for (unsigned i = 0; i != NumObjects; ++i) { |
1938 | unsigned CleanupKind = Record.readInt(); |
1939 | ExprWithCleanups::CleanupObject Obj; |
1940 | if (CleanupKind == COK_Block) |
1941 | Obj = readDeclAs<BlockDecl>(); |
1942 | else if (CleanupKind == COK_CompoundLiteral) |
1943 | Obj = cast<CompoundLiteralExpr>(Record.readSubExpr()); |
1944 | else |
1945 | llvm_unreachable("unexpected cleanup object type"); |
1946 | E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj; |
1947 | } |
1948 | |
1949 | E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt(); |
1950 | E->SubExpr = Record.readSubExpr(); |
1951 | } |
1952 | |
1953 | void ASTStmtReader::VisitCXXDependentScopeMemberExpr( |
1954 | CXXDependentScopeMemberExpr *E) { |
1955 | VisitExpr(E); |
1956 | |
1957 | bool HasTemplateKWAndArgsInfo = Record.readInt(); |
1958 | unsigned NumTemplateArgs = Record.readInt(); |
1959 | bool HasFirstQualifierFoundInScope = Record.readInt(); |
1960 | |
1961 | assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) && |
1962 | "Wrong HasTemplateKWAndArgsInfo!"); |
1963 | assert( |
1964 | (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) && |
1965 | "Wrong HasFirstQualifierFoundInScope!"); |
1966 | |
1967 | if (HasTemplateKWAndArgsInfo) |
1968 | ReadTemplateKWAndArgsInfo( |
1969 | *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), |
1970 | E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); |
1971 | |
1972 | assert((NumTemplateArgs == E->getNumTemplateArgs()) && |
1973 | "Wrong NumTemplateArgs!"); |
1974 | |
1975 | E->CXXDependentScopeMemberExprBits.IsArrow = Record.readInt(); |
1976 | E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation(); |
1977 | E->BaseType = Record.readType(); |
1978 | E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
1979 | E->Base = Record.readSubExpr(); |
1980 | |
1981 | if (HasFirstQualifierFoundInScope) |
1982 | *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>(); |
1983 | |
1984 | E->MemberNameInfo = Record.readDeclarationNameInfo(); |
1985 | } |
1986 | |
1987 | void |
1988 | ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { |
1989 | VisitExpr(E); |
1990 | |
1991 | if (Record.readInt()) |
1992 | ReadTemplateKWAndArgsInfo( |
1993 | *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), |
1994 | E->getTrailingObjects<TemplateArgumentLoc>(), |
1995 | Record.readInt()); |
1996 | |
1997 | E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
1998 | E->NameInfo = Record.readDeclarationNameInfo(); |
1999 | } |
2000 | |
2001 | void |
2002 | ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { |
2003 | VisitExpr(E); |
2004 | assert(Record.peekInt() == E->getNumArgs() && |
2005 | "Read wrong record during creation ?"); |
2006 | Record.skipInts(1); |
2007 | for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) |
2008 | E->setArg(I, Record.readSubExpr()); |
2009 | E->TSI = readTypeSourceInfo(); |
2010 | E->setLParenLoc(readSourceLocation()); |
2011 | E->setRParenLoc(readSourceLocation()); |
2012 | } |
2013 | |
2014 | void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) { |
2015 | VisitExpr(E); |
2016 | |
2017 | unsigned NumResults = Record.readInt(); |
2018 | bool HasTemplateKWAndArgsInfo = Record.readInt(); |
2019 | assert((E->getNumDecls() == NumResults) && "Wrong NumResults!"); |
2020 | assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) && |
2021 | "Wrong HasTemplateKWAndArgsInfo!"); |
2022 | |
2023 | if (HasTemplateKWAndArgsInfo) { |
2024 | unsigned NumTemplateArgs = Record.readInt(); |
2025 | ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(), |
2026 | E->getTrailingTemplateArgumentLoc(), |
2027 | NumTemplateArgs); |
2028 | assert((E->getNumTemplateArgs() == NumTemplateArgs) && |
2029 | "Wrong NumTemplateArgs!"); |
2030 | } |
2031 | |
2032 | UnresolvedSet<8> Decls; |
2033 | for (unsigned I = 0; I != NumResults; ++I) { |
2034 | auto *D = readDeclAs<NamedDecl>(); |
2035 | auto AS = (AccessSpecifier)Record.readInt(); |
2036 | Decls.addDecl(D, AS); |
2037 | } |
2038 | |
2039 | DeclAccessPair *Results = E->getTrailingResults(); |
2040 | UnresolvedSetIterator Iter = Decls.begin(); |
2041 | for (unsigned I = 0; I != NumResults; ++I) { |
2042 | Results[I] = (Iter + I).getPair(); |
2043 | } |
2044 | |
2045 | E->NameInfo = Record.readDeclarationNameInfo(); |
2046 | E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
2047 | } |
2048 | |
2049 | void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { |
2050 | VisitOverloadExpr(E); |
2051 | E->UnresolvedMemberExprBits.IsArrow = Record.readInt(); |
2052 | E->UnresolvedMemberExprBits.HasUnresolvedUsing = Record.readInt(); |
2053 | E->Base = Record.readSubExpr(); |
2054 | E->BaseType = Record.readType(); |
2055 | E->OperatorLoc = readSourceLocation(); |
2056 | } |
2057 | |
2058 | void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { |
2059 | VisitOverloadExpr(E); |
2060 | E->UnresolvedLookupExprBits.RequiresADL = Record.readInt(); |
2061 | E->UnresolvedLookupExprBits.Overloaded = Record.readInt(); |
2062 | E->NamingClass = readDeclAs<CXXRecordDecl>(); |
2063 | } |
2064 | |
2065 | void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) { |
2066 | VisitExpr(E); |
2067 | E->TypeTraitExprBits.NumArgs = Record.readInt(); |
2068 | E->TypeTraitExprBits.Kind = Record.readInt(); |
2069 | E->TypeTraitExprBits.Value = Record.readInt(); |
2070 | SourceRange Range = readSourceRange(); |
2071 | E->Loc = Range.getBegin(); |
2072 | E->RParenLoc = Range.getEnd(); |
2073 | |
2074 | auto **Args = E->getTrailingObjects<TypeSourceInfo *>(); |
2075 | for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) |
2076 | Args[I] = readTypeSourceInfo(); |
2077 | } |
2078 | |
2079 | void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { |
2080 | VisitExpr(E); |
2081 | E->ATT = (ArrayTypeTrait)Record.readInt(); |
2082 | E->Value = (unsigned int)Record.readInt(); |
2083 | SourceRange Range = readSourceRange(); |
2084 | E->Loc = Range.getBegin(); |
2085 | E->RParen = Range.getEnd(); |
2086 | E->QueriedType = readTypeSourceInfo(); |
2087 | E->Dimension = Record.readSubExpr(); |
2088 | } |
2089 | |
2090 | void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { |
2091 | VisitExpr(E); |
2092 | E->ET = (ExpressionTrait)Record.readInt(); |
2093 | E->Value = (bool)Record.readInt(); |
2094 | SourceRange Range = readSourceRange(); |
2095 | E->QueriedExpression = Record.readSubExpr(); |
2096 | E->Loc = Range.getBegin(); |
2097 | E->RParen = Range.getEnd(); |
2098 | } |
2099 | |
2100 | void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { |
2101 | VisitExpr(E); |
2102 | E->CXXNoexceptExprBits.Value = Record.readInt(); |
2103 | E->Range = readSourceRange(); |
2104 | E->Operand = Record.readSubExpr(); |
2105 | } |
2106 | |
2107 | void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) { |
2108 | VisitExpr(E); |
2109 | E->EllipsisLoc = readSourceLocation(); |
2110 | E->NumExpansions = Record.readInt(); |
2111 | E->Pattern = Record.readSubExpr(); |
2112 | } |
2113 | |
2114 | void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) { |
2115 | VisitExpr(E); |
2116 | unsigned NumPartialArgs = Record.readInt(); |
2117 | E->OperatorLoc = readSourceLocation(); |
2118 | E->PackLoc = readSourceLocation(); |
2119 | E->RParenLoc = readSourceLocation(); |
2120 | E->Pack = Record.readDeclAs<NamedDecl>(); |
2121 | if (E->isPartiallySubstituted()) { |
2122 | assert(E->Length == NumPartialArgs); |
2123 | for (auto *I = E->getTrailingObjects<TemplateArgument>(), |
2124 | *E = I + NumPartialArgs; |
2125 | I != E; ++I) |
2126 | new (I) TemplateArgument(Record.readTemplateArgument()); |
2127 | } else if (!E->isValueDependent()) { |
2128 | E->Length = Record.readInt(); |
2129 | } |
2130 | } |
2131 | |
2132 | void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr( |
2133 | SubstNonTypeTemplateParmExpr *E) { |
2134 | VisitExpr(E); |
2135 | E->ParamAndRef.setPointer(readDeclAs<NonTypeTemplateParmDecl>()); |
2136 | E->ParamAndRef.setInt(Record.readInt()); |
2137 | E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation(); |
2138 | E->Replacement = Record.readSubExpr(); |
2139 | } |
2140 | |
2141 | void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr( |
2142 | SubstNonTypeTemplateParmPackExpr *E) { |
2143 | VisitExpr(E); |
2144 | E->Param = readDeclAs<NonTypeTemplateParmDecl>(); |
2145 | TemplateArgument ArgPack = Record.readTemplateArgument(); |
2146 | if (ArgPack.getKind() != TemplateArgument::Pack) |
2147 | return; |
2148 | |
2149 | E->Arguments = ArgPack.pack_begin(); |
2150 | E->NumArguments = ArgPack.pack_size(); |
2151 | E->NameLoc = readSourceLocation(); |
2152 | } |
2153 | |
2154 | void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { |
2155 | VisitExpr(E); |
2156 | E->NumParameters = Record.readInt(); |
2157 | E->ParamPack = readDeclAs<ParmVarDecl>(); |
2158 | E->NameLoc = readSourceLocation(); |
2159 | auto **Parms = E->getTrailingObjects<VarDecl *>(); |
2160 | for (unsigned i = 0, n = E->NumParameters; i != n; ++i) |
2161 | Parms[i] = readDeclAs<VarDecl>(); |
2162 | } |
2163 | |
2164 | void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { |
2165 | VisitExpr(E); |
2166 | bool HasMaterialzedDecl = Record.readInt(); |
2167 | if (HasMaterialzedDecl) |
2168 | E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl()); |
2169 | else |
2170 | E->State = Record.readSubExpr(); |
2171 | } |
2172 | |
2173 | void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) { |
2174 | VisitExpr(E); |
2175 | E->LParenLoc = readSourceLocation(); |
2176 | E->EllipsisLoc = readSourceLocation(); |
2177 | E->RParenLoc = readSourceLocation(); |
2178 | E->NumExpansions = Record.readInt(); |
2179 | E->SubExprs[0] = Record.readSubExpr(); |
2180 | E->SubExprs[1] = Record.readSubExpr(); |
2181 | E->SubExprs[2] = Record.readSubExpr(); |
2182 | E->Opcode = (BinaryOperatorKind)Record.readInt(); |
2183 | } |
2184 | |
2185 | void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) { |
2186 | VisitExpr(E); |
2187 | E->SourceExpr = Record.readSubExpr(); |
2188 | E->OpaqueValueExprBits.Loc = readSourceLocation(); |
2189 | E->setIsUnique(Record.readInt()); |
2190 | } |
2191 | |
2192 | void ASTStmtReader::VisitTypoExpr(TypoExpr *E) { |
2193 | llvm_unreachable("Cannot read TypoExpr nodes"); |
2194 | } |
2195 | |
2196 | void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) { |
2197 | VisitExpr(E); |
2198 | unsigned NumArgs = Record.readInt(); |
2199 | E->BeginLoc = readSourceLocation(); |
2200 | E->EndLoc = readSourceLocation(); |
2201 | assert((NumArgs + 0LL == |
2202 | std::distance(E->children().begin(), E->children().end())) && |
2203 | "Wrong NumArgs!"); |
2204 | (void)NumArgs; |
2205 | for (Stmt *&Child : E->children()) |
2206 | Child = Record.readSubStmt(); |
2207 | } |
2208 | |
2209 | |
2210 | |
2211 | |
2212 | void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { |
2213 | VisitExpr(E); |
2214 | E->IsArrow = (Record.readInt() != 0); |
2215 | E->BaseExpr = Record.readSubExpr(); |
2216 | E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
2217 | E->MemberLoc = readSourceLocation(); |
2218 | E->TheDecl = readDeclAs<MSPropertyDecl>(); |
2219 | } |
2220 | |
2221 | void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) { |
2222 | VisitExpr(E); |
2223 | E->setBase(Record.readSubExpr()); |
2224 | E->setIdx(Record.readSubExpr()); |
2225 | E->setRBracketLoc(readSourceLocation()); |
2226 | } |
2227 | |
2228 | void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) { |
2229 | VisitExpr(E); |
2230 | E->setSourceRange(readSourceRange()); |
2231 | E->Guid = readDeclAs<MSGuidDecl>(); |
2232 | if (E->isTypeOperand()) |
2233 | E->Operand = readTypeSourceInfo(); |
2234 | else |
2235 | E->Operand = Record.readSubExpr(); |
2236 | } |
2237 | |
2238 | void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) { |
2239 | VisitStmt(S); |
2240 | S->setLeaveLoc(readSourceLocation()); |
2241 | } |
2242 | |
2243 | void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) { |
2244 | VisitStmt(S); |
2245 | S->Loc = readSourceLocation(); |
2246 | S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt(); |
2247 | S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt(); |
2248 | } |
2249 | |
2250 | void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) { |
2251 | VisitStmt(S); |
2252 | S->Loc = readSourceLocation(); |
2253 | S->Block = Record.readSubStmt(); |
2254 | } |
2255 | |
2256 | void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) { |
2257 | VisitStmt(S); |
2258 | S->IsCXXTry = Record.readInt(); |
2259 | S->TryLoc = readSourceLocation(); |
2260 | S->Children[SEHTryStmt::TRY] = Record.readSubStmt(); |
2261 | S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt(); |
2262 | } |
2263 | |
2264 | |
2265 | |
2266 | |
2267 | |
2268 | void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { |
2269 | VisitCallExpr(E); |
2270 | E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr()); |
2271 | } |
2272 | |
2273 | |
2274 | |
2275 | |
2276 | void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) { |
2277 | VisitExpr(E); |
2278 | E->BuiltinLoc = readSourceLocation(); |
2279 | E->RParenLoc = readSourceLocation(); |
2280 | E->SrcExpr = Record.readSubExpr(); |
2281 | } |
2282 | |
2283 | |
2284 | |
2285 | |
2286 | |
2287 | void ASTStmtReader::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) { |
2288 | VisitStmt(S); |
2289 | for (Stmt *&SubStmt : S->SubStmts) |
2290 | SubStmt = Record.readSubStmt(); |
2291 | } |
2292 | |
2293 | void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) { |
2294 | Record.readOMPChildren(E->Data); |
2295 | E->setLocStart(readSourceLocation()); |
2296 | E->setLocEnd(readSourceLocation()); |
2297 | } |
2298 | |
2299 | void ASTStmtReader::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) { |
2300 | VisitStmt(D); |
2301 | |
2302 | Record.skipInts(1); |
2303 | VisitOMPExecutableDirective(D); |
2304 | } |
2305 | |
2306 | void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) { |
2307 | VisitOMPLoopBasedDirective(D); |
2308 | } |
2309 | |
2310 | void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) { |
2311 | VisitStmt(D); |
2312 | VisitOMPExecutableDirective(D); |
2313 | D->setHasCancel(Record.readBool()); |
2314 | } |
2315 | |
2316 | void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) { |
2317 | VisitOMPLoopDirective(D); |
2318 | } |
2319 | |
2320 | void ASTStmtReader::VisitOMPTileDirective(OMPTileDirective *D) { |
2321 | VisitOMPLoopBasedDirective(D); |
2322 | } |
2323 | |
2324 | void ASTStmtReader::VisitOMPUnrollDirective(OMPUnrollDirective *D) { |
2325 | VisitOMPLoopBasedDirective(D); |
2326 | } |
2327 | |
2328 | void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) { |
2329 | VisitOMPLoopDirective(D); |
2330 | D->setHasCancel(Record.readBool()); |
2331 | } |
2332 | |
2333 | void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) { |
2334 | VisitOMPLoopDirective(D); |
2335 | } |
2336 | |
2337 | void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) { |
2338 | VisitStmt(D); |
2339 | VisitOMPExecutableDirective(D); |
2340 | D->setHasCancel(Record.readBool()); |
2341 | } |
2342 | |
2343 | void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) { |
2344 | VisitStmt(D); |
2345 | VisitOMPExecutableDirective(D); |
2346 | D->setHasCancel(Record.readBool()); |
2347 | } |
2348 | |
2349 | void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) { |
2350 | VisitStmt(D); |
2351 | VisitOMPExecutableDirective(D); |
2352 | } |
2353 | |
2354 | void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) { |
2355 | VisitStmt(D); |
2356 | VisitOMPExecutableDirective(D); |
2357 | } |
2358 | |
2359 | void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) { |
2360 | VisitStmt(D); |
2361 | VisitOMPExecutableDirective(D); |
2362 | D->DirName = Record.readDeclarationNameInfo(); |
2363 | } |
2364 | |
2365 | void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) { |
2366 | VisitOMPLoopDirective(D); |
2367 | D->setHasCancel(Record.readBool()); |
2368 | } |
2369 | |
2370 | void ASTStmtReader::VisitOMPParallelForSimdDirective( |
2371 | OMPParallelForSimdDirective *D) { |
2372 | VisitOMPLoopDirective(D); |
2373 | } |
2374 | |
2375 | void ASTStmtReader::VisitOMPParallelMasterDirective( |
2376 | OMPParallelMasterDirective *D) { |
2377 | VisitStmt(D); |
2378 | VisitOMPExecutableDirective(D); |
2379 | } |
2380 | |
2381 | void ASTStmtReader::VisitOMPParallelSectionsDirective( |
2382 | OMPParallelSectionsDirective *D) { |
2383 | VisitStmt(D); |
2384 | VisitOMPExecutableDirective(D); |
2385 | D->setHasCancel(Record.readBool()); |
2386 | } |
2387 | |
2388 | void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) { |
2389 | VisitStmt(D); |
2390 | VisitOMPExecutableDirective(D); |
2391 | D->setHasCancel(Record.readBool()); |
2392 | } |
2393 | |
2394 | void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { |
2395 | VisitStmt(D); |
2396 | VisitOMPExecutableDirective(D); |
2397 | } |
2398 | |
2399 | void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) { |
2400 | VisitStmt(D); |
2401 | VisitOMPExecutableDirective(D); |
2402 | } |
2403 | |
2404 | void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { |
2405 | VisitStmt(D); |
2406 | VisitOMPExecutableDirective(D); |
2407 | } |
2408 | |
2409 | void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { |
2410 | VisitStmt(D); |
2411 | VisitOMPExecutableDirective(D); |
2412 | } |
2413 | |
2414 | void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) { |
2415 | VisitStmt(D); |
2416 | VisitOMPExecutableDirective(D); |
2417 | } |
2418 | |
2419 | void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) { |
2420 | VisitStmt(D); |
2421 | VisitOMPExecutableDirective(D); |
2422 | } |
2423 | |
2424 | void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) { |
2425 | VisitStmt(D); |
2426 | VisitOMPExecutableDirective(D); |
2427 | } |
2428 | |
2429 | void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) { |
2430 | VisitStmt(D); |
2431 | VisitOMPExecutableDirective(D); |
2432 | } |
2433 | |
2434 | void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) { |
2435 | VisitStmt(D); |
2436 | VisitOMPExecutableDirective(D); |
2437 | D->IsXLHSInRHSPart = Record.readBool(); |
2438 | D->IsPostfixUpdate = Record.readBool(); |
2439 | } |
2440 | |
2441 | void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) { |
2442 | VisitStmt(D); |
2443 | VisitOMPExecutableDirective(D); |
2444 | } |
2445 | |
2446 | void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { |
2447 | VisitStmt(D); |
2448 | VisitOMPExecutableDirective(D); |
2449 | } |
2450 | |
2451 | void ASTStmtReader::VisitOMPTargetEnterDataDirective( |
2452 | OMPTargetEnterDataDirective *D) { |
2453 | VisitStmt(D); |
2454 | VisitOMPExecutableDirective(D); |
2455 | } |
2456 | |
2457 | void ASTStmtReader::VisitOMPTargetExitDataDirective( |
2458 | OMPTargetExitDataDirective *D) { |
2459 | VisitStmt(D); |
2460 | VisitOMPExecutableDirective(D); |
2461 | } |
2462 | |
2463 | void ASTStmtReader::VisitOMPTargetParallelDirective( |
2464 | OMPTargetParallelDirective *D) { |
2465 | VisitStmt(D); |
2466 | VisitOMPExecutableDirective(D); |
2467 | D->setHasCancel(Record.readBool()); |
2468 | } |
2469 | |
2470 | void ASTStmtReader::VisitOMPTargetParallelForDirective( |
2471 | OMPTargetParallelForDirective *D) { |
2472 | VisitOMPLoopDirective(D); |
2473 | D->setHasCancel(Record.readBool()); |
2474 | } |
2475 | |
2476 | void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) { |
2477 | VisitStmt(D); |
2478 | VisitOMPExecutableDirective(D); |
2479 | } |
2480 | |
2481 | void ASTStmtReader::VisitOMPCancellationPointDirective( |
2482 | OMPCancellationPointDirective *D) { |
2483 | VisitStmt(D); |
2484 | VisitOMPExecutableDirective(D); |
2485 | D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>()); |
2486 | } |
2487 | |
2488 | void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) { |
2489 | VisitStmt(D); |
2490 | VisitOMPExecutableDirective(D); |
2491 | D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>()); |
2492 | } |
2493 | |
2494 | void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { |
2495 | VisitOMPLoopDirective(D); |
2496 | D->setHasCancel(Record.readBool()); |
2497 | } |
2498 | |
2499 | void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) { |
2500 | VisitOMPLoopDirective(D); |
2501 | } |
2502 | |
2503 | void ASTStmtReader::VisitOMPMasterTaskLoopDirective( |
2504 | OMPMasterTaskLoopDirective *D) { |
2505 | VisitOMPLoopDirective(D); |
2506 | D->setHasCancel(Record.readBool()); |
2507 | } |
2508 | |
2509 | void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective( |
2510 | OMPMasterTaskLoopSimdDirective *D) { |
2511 | VisitOMPLoopDirective(D); |
2512 | } |
2513 | |
2514 | void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective( |
2515 | OMPParallelMasterTaskLoopDirective *D) { |
2516 | VisitOMPLoopDirective(D); |
2517 | D->setHasCancel(Record.readBool()); |
2518 | } |
2519 | |
2520 | void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective( |
2521 | OMPParallelMasterTaskLoopSimdDirective *D) { |
2522 | VisitOMPLoopDirective(D); |
2523 | } |
2524 | |
2525 | void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) { |
2526 | VisitOMPLoopDirective(D); |
2527 | } |
2528 | |
2529 | void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) { |
2530 | VisitStmt(D); |
2531 | VisitOMPExecutableDirective(D); |
2532 | } |
2533 | |
2534 | void ASTStmtReader::VisitOMPDistributeParallelForDirective( |
2535 | OMPDistributeParallelForDirective *D) { |
2536 | VisitOMPLoopDirective(D); |
2537 | D->setHasCancel(Record.readBool()); |
2538 | } |
2539 | |
2540 | void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective( |
2541 | OMPDistributeParallelForSimdDirective *D) { |
2542 | VisitOMPLoopDirective(D); |
2543 | } |
2544 | |
2545 | void ASTStmtReader::VisitOMPDistributeSimdDirective( |
2546 | OMPDistributeSimdDirective *D) { |
2547 | VisitOMPLoopDirective(D); |
2548 | } |
2549 | |
2550 | void ASTStmtReader::VisitOMPTargetParallelForSimdDirective( |
2551 | OMPTargetParallelForSimdDirective *D) { |
2552 | VisitOMPLoopDirective(D); |
2553 | } |
2554 | |
2555 | void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) { |
2556 | VisitOMPLoopDirective(D); |
2557 | } |
2558 | |
2559 | void ASTStmtReader::VisitOMPTeamsDistributeDirective( |
2560 | OMPTeamsDistributeDirective *D) { |
2561 | VisitOMPLoopDirective(D); |
2562 | } |
2563 | |
2564 | void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective( |
2565 | OMPTeamsDistributeSimdDirective *D) { |
2566 | VisitOMPLoopDirective(D); |
2567 | } |
2568 | |
2569 | void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective( |
2570 | OMPTeamsDistributeParallelForSimdDirective *D) { |
2571 | VisitOMPLoopDirective(D); |
2572 | } |
2573 | |
2574 | void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective( |
2575 | OMPTeamsDistributeParallelForDirective *D) { |
2576 | VisitOMPLoopDirective(D); |
2577 | D->setHasCancel(Record.readBool()); |
2578 | } |
2579 | |
2580 | void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) { |
2581 | VisitStmt(D); |
2582 | VisitOMPExecutableDirective(D); |
2583 | } |
2584 | |
2585 | void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective( |
2586 | OMPTargetTeamsDistributeDirective *D) { |
2587 | VisitOMPLoopDirective(D); |
2588 | } |
2589 | |
2590 | void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective( |
2591 | OMPTargetTeamsDistributeParallelForDirective *D) { |
2592 | VisitOMPLoopDirective(D); |
2593 | D->setHasCancel(Record.readBool()); |
2594 | } |
2595 | |
2596 | void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective( |
2597 | OMPTargetTeamsDistributeParallelForSimdDirective *D) { |
2598 | VisitOMPLoopDirective(D); |
2599 | } |
2600 | |
2601 | void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective( |
2602 | OMPTargetTeamsDistributeSimdDirective *D) { |
2603 | VisitOMPLoopDirective(D); |
2604 | } |
2605 | |
2606 | void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) { |
2607 | VisitStmt(D); |
2608 | VisitOMPExecutableDirective(D); |
2609 | } |
2610 | |
2611 | void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) { |
2612 | VisitStmt(D); |
2613 | VisitOMPExecutableDirective(D); |
2614 | D->setTargetCallLoc(Record.readSourceLocation()); |
2615 | } |
2616 | |
2617 | void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) { |
2618 | VisitStmt(D); |
2619 | VisitOMPExecutableDirective(D); |
2620 | } |
2621 | |
2622 | |
2623 | |
2624 | |
2625 | |
2626 | Stmt *ASTReader::ReadStmt(ModuleFile &F) { |
2627 | switch (ReadingKind) { |
2628 | case Read_None: |
2629 | llvm_unreachable("should not call this when not reading anything"); |
2630 | case Read_Decl: |
2631 | case Read_Type: |
2632 | return ReadStmtFromStream(F); |
2633 | case Read_Stmt: |
2634 | return ReadSubStmt(); |
2635 | } |
2636 | |
2637 | llvm_unreachable("ReadingKind not set ?"); |
2638 | } |
2639 | |
2640 | Expr *ASTReader::ReadExpr(ModuleFile &F) { |
2641 | return cast_or_null<Expr>(ReadStmt(F)); |
2642 | } |
2643 | |
2644 | Expr *ASTReader::ReadSubExpr() { |
2645 | return cast_or_null<Expr>(ReadSubStmt()); |
2646 | } |
2647 | |
2648 | |
2649 | |
2650 | |
2651 | |
2652 | |
2653 | |
2654 | |
2655 | Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { |
2656 | ReadingKindTracker ReadingKind(Read_Stmt, *this); |
2657 | llvm::BitstreamCursor &Cursor = F.DeclsCursor; |
2658 | |
2659 | |
2660 | |
2661 | llvm::DenseMap<uint64_t, Stmt *> StmtEntries; |
2662 | |
2663 | #ifndef NDEBUG |
2664 | unsigned PrevNumStmts = StmtStack.size(); |
2665 | #endif |
2666 | |
2667 | ASTRecordReader Record(*this, F); |
2668 | ASTStmtReader Reader(Record, Cursor); |
2669 | Stmt::EmptyShell Empty; |
2670 | |
2671 | while (true) { |
| 1 | Loop condition is true. Entering loop body | |
|
2672 | llvm::Expected<llvm::BitstreamEntry> MaybeEntry = |
2673 | Cursor.advanceSkippingSubblocks(); |
| 2 | | Calling 'BitstreamCursor::advanceSkippingSubblocks' | |
|
2674 | if (!MaybeEntry) { |
2675 | Error(toString(MaybeEntry.takeError())); |
2676 | return nullptr; |
2677 | } |
2678 | llvm::BitstreamEntry Entry = MaybeEntry.get(); |
2679 | |
2680 | switch (Entry.Kind) { |
2681 | case llvm::BitstreamEntry::SubBlock: |
2682 | case llvm::BitstreamEntry::Error: |
2683 | Error("malformed block record in AST file"); |
2684 | return nullptr; |
2685 | case llvm::BitstreamEntry::EndBlock: |
2686 | goto Done; |
2687 | case llvm::BitstreamEntry::Record: |
2688 | |
2689 | break; |
2690 | } |
2691 | |
2692 | ASTContext &Context = getContext(); |
2693 | Stmt *S = nullptr; |
2694 | bool Finished = false; |
2695 | bool IsStmtReference = false; |
2696 | Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID); |
2697 | if (!MaybeStmtCode) { |
2698 | Error(toString(MaybeStmtCode.takeError())); |
2699 | return nullptr; |
2700 | } |
2701 | switch ((StmtCode)MaybeStmtCode.get()) { |
2702 | case STMT_STOP: |
2703 | Finished = true; |
2704 | break; |
2705 | |
2706 | case STMT_REF_PTR: |
2707 | IsStmtReference = true; |
2708 | assert(StmtEntries.find(Record[0]) != StmtEntries.end() && |
2709 | "No stmt was recorded for this offset reference!"); |
2710 | S = StmtEntries[Record.readInt()]; |
2711 | break; |
2712 | |
2713 | case STMT_NULL_PTR: |
2714 | S = nullptr; |
2715 | break; |
2716 | |
2717 | case STMT_NULL: |
2718 | S = new (Context) NullStmt(Empty); |
2719 | break; |
2720 | |
2721 | case STMT_COMPOUND: |
2722 | S = CompoundStmt::CreateEmpty( |
2723 | Context, Record[ASTStmtReader::NumStmtFields]); |
2724 | break; |
2725 | |
2726 | case STMT_CASE: |
2727 | S = CaseStmt::CreateEmpty( |
2728 | Context, |
2729 | Record[ASTStmtReader::NumStmtFields + 3]); |
2730 | break; |
2731 | |
2732 | case STMT_DEFAULT: |
2733 | S = new (Context) DefaultStmt(Empty); |
2734 | break; |
2735 | |
2736 | case STMT_LABEL: |
2737 | S = new (Context) LabelStmt(Empty); |
2738 | break; |
2739 | |
2740 | case STMT_ATTRIBUTED: |
2741 | S = AttributedStmt::CreateEmpty( |
2742 | Context, |
2743 | Record[ASTStmtReader::NumStmtFields]); |
2744 | break; |
2745 | |
2746 | case STMT_IF: |
2747 | S = IfStmt::CreateEmpty( |
2748 | Context, |
2749 | Record[ASTStmtReader::NumStmtFields + 1], |
2750 | Record[ASTStmtReader::NumStmtFields + 2], |
2751 | Record[ASTStmtReader::NumStmtFields + 3]); |
2752 | break; |
2753 | |
2754 | case STMT_SWITCH: |
2755 | S = SwitchStmt::CreateEmpty( |
2756 | Context, |
2757 | Record[ASTStmtReader::NumStmtFields], |
2758 | Record[ASTStmtReader::NumStmtFields + 1]); |
2759 | break; |
2760 | |
2761 | case STMT_WHILE: |
2762 | S = WhileStmt::CreateEmpty( |
2763 | Context, |
2764 | Record[ASTStmtReader::NumStmtFields]); |
2765 | break; |
2766 | |
2767 | case STMT_DO: |
2768 | S = new (Context) DoStmt(Empty); |
2769 | break; |
2770 | |
2771 | case STMT_FOR: |
2772 | S = new (Context) ForStmt(Empty); |
2773 | break; |
2774 | |
2775 | case STMT_GOTO: |
2776 | S = new (Context) GotoStmt(Empty); |
2777 | break; |
2778 | |
2779 | case STMT_INDIRECT_GOTO: |
2780 | S = new (Context) IndirectGotoStmt(Empty); |
2781 | break; |
2782 | |
2783 | case STMT_CONTINUE: |
2784 | S = new (Context) ContinueStmt(Empty); |
2785 | break; |
2786 | |
2787 | case STMT_BREAK: |
2788 | S = new (Context) BreakStmt(Empty); |
2789 | break; |
2790 | |
2791 | case STMT_RETURN: |
2792 | S = ReturnStmt::CreateEmpty( |
2793 | Context, Record[ASTStmtReader::NumStmtFields]); |
2794 | break; |
2795 | |
2796 | case STMT_DECL: |
2797 | S = new (Context) DeclStmt(Empty); |
2798 | break; |
2799 | |
2800 | case STMT_GCCASM: |
2801 | S = new (Context) GCCAsmStmt(Empty); |
2802 | break; |
2803 | |
2804 | case STMT_MSASM: |
2805 | S = new (Context) MSAsmStmt(Empty); |
2806 | break; |
2807 | |
2808 | case STMT_CAPTURED: |
2809 | S = CapturedStmt::CreateDeserialized( |
2810 | Context, Record[ASTStmtReader::NumStmtFields]); |
2811 | break; |
2812 | |
2813 | case EXPR_CONSTANT: |
2814 | S = ConstantExpr::CreateEmpty( |
2815 | Context, static_cast<ConstantExpr::ResultStorageKind>( |
2816 | Record[ASTStmtReader::NumExprFields])); |
2817 | break; |
2818 | |
2819 | case EXPR_SYCL_UNIQUE_STABLE_NAME: |
2820 | S = SYCLUniqueStableNameExpr::CreateEmpty(Context); |
2821 | break; |
2822 | |
2823 | case EXPR_PREDEFINED: |
2824 | S = PredefinedExpr::CreateEmpty( |
2825 | Context, |
2826 | Record[ASTStmtReader::NumExprFields]); |
2827 | break; |
2828 | |
2829 | case EXPR_DECL_REF: |
2830 | S = DeclRefExpr::CreateEmpty( |
2831 | Context, |
2832 | Record[ASTStmtReader::NumExprFields], |
2833 | Record[ASTStmtReader::NumExprFields + 1], |
2834 | Record[ASTStmtReader::NumExprFields + 2], |
2835 | Record[ASTStmtReader::NumExprFields + 2] ? |
2836 | Record[ASTStmtReader::NumExprFields + 6] : 0); |
2837 | break; |
2838 | |
2839 | case EXPR_INTEGER_LITERAL: |
2840 | S = IntegerLiteral::Create(Context, Empty); |
2841 | break; |
2842 | |
2843 | case EXPR_FIXEDPOINT_LITERAL: |
2844 | S = FixedPointLiteral::Create(Context, Empty); |
2845 | break; |
2846 | |
2847 | case EXPR_FLOATING_LITERAL: |
2848 | S = FloatingLiteral::Create(Context, Empty); |
2849 | break; |
2850 | |
2851 | case EXPR_IMAGINARY_LITERAL: |
2852 | S = new (Context) ImaginaryLiteral(Empty); |
2853 | break; |
2854 | |
2855 | case EXPR_STRING_LITERAL: |
2856 | S = StringLiteral::CreateEmpty( |
2857 | Context, |
2858 | Record[ASTStmtReader::NumExprFields], |
2859 | Record[ASTStmtReader::NumExprFields + 1], |
2860 | Record[ASTStmtReader::NumExprFields + 2]); |
2861 | break; |
2862 | |
2863 | case EXPR_CHARACTER_LITERAL: |
2864 | S = new (Context) CharacterLiteral(Empty); |
2865 | break; |
2866 | |
2867 | case EXPR_PAREN: |
2868 | S = new (Context) ParenExpr(Empty); |
2869 | break; |
2870 | |
2871 | case EXPR_PAREN_LIST: |
2872 | S = ParenListExpr::CreateEmpty( |
2873 | Context, |
2874 | Record[ASTStmtReader::NumExprFields]); |
2875 | break; |
2876 | |
2877 | case EXPR_UNARY_OPERATOR: |
2878 | S = UnaryOperator::CreateEmpty(Context, |
2879 | Record[ASTStmtReader::NumExprFields]); |
2880 | break; |
2881 | |
2882 | case EXPR_OFFSETOF: |
2883 | S = OffsetOfExpr::CreateEmpty(Context, |
2884 | Record[ASTStmtReader::NumExprFields], |
2885 | Record[ASTStmtReader::NumExprFields + 1]); |
2886 | break; |
2887 | |
2888 | case EXPR_SIZEOF_ALIGN_OF: |
2889 | S = new (Context) UnaryExprOrTypeTraitExpr(Empty); |
2890 | break; |
2891 | |
2892 | case EXPR_ARRAY_SUBSCRIPT: |
2893 | S = new (Context) ArraySubscriptExpr(Empty); |
2894 | break; |
2895 | |
2896 | case EXPR_MATRIX_SUBSCRIPT: |
2897 | S = new (Context) MatrixSubscriptExpr(Empty); |
2898 | break; |
2899 | |
2900 | case EXPR_OMP_ARRAY_SECTION: |
2901 | S = new (Context) OMPArraySectionExpr(Empty); |
2902 | break; |
2903 | |
2904 | case EXPR_OMP_ARRAY_SHAPING: |
2905 | S = OMPArrayShapingExpr::CreateEmpty( |
2906 | Context, Record[ASTStmtReader::NumExprFields]); |
2907 | break; |
2908 | |
2909 | case EXPR_OMP_ITERATOR: |
2910 | S = OMPIteratorExpr::CreateEmpty(Context, |
2911 | Record[ASTStmtReader::NumExprFields]); |
2912 | break; |
2913 | |
2914 | case EXPR_CALL: |
2915 | S = CallExpr::CreateEmpty( |
2916 | Context, Record[ASTStmtReader::NumExprFields], |
2917 | Record[ASTStmtReader::NumExprFields + 1], Empty); |
2918 | break; |
2919 | |
2920 | case EXPR_RECOVERY: |
2921 | S = RecoveryExpr::CreateEmpty( |
2922 | Context, Record[ASTStmtReader::NumExprFields]); |
2923 | break; |
2924 | |
2925 | case EXPR_MEMBER: |
2926 | S = MemberExpr::CreateEmpty(Context, Record[ASTStmtReader::NumExprFields], |
2927 | Record[ASTStmtReader::NumExprFields + 1], |
2928 | Record[ASTStmtReader::NumExprFields + 2], |
2929 | Record[ASTStmtReader::NumExprFields + 3]); |
2930 | break; |
2931 | |
2932 | case EXPR_BINARY_OPERATOR: |
2933 | S = BinaryOperator::CreateEmpty(Context, |
2934 | Record[ASTStmtReader::NumExprFields]); |
2935 | break; |
2936 | |
2937 | case EXPR_COMPOUND_ASSIGN_OPERATOR: |
2938 | S = CompoundAssignOperator::CreateEmpty( |
2939 | Context, Record[ASTStmtReader::NumExprFields]); |
2940 | break; |
2941 | |
2942 | case EXPR_CONDITIONAL_OPERATOR: |
2943 | S = new (Context) ConditionalOperator(Empty); |
2944 | break; |
2945 | |
2946 | case EXPR_BINARY_CONDITIONAL_OPERATOR: |
2947 | S = new (Context) BinaryConditionalOperator(Empty); |
2948 | break; |
2949 | |
2950 | case EXPR_IMPLICIT_CAST: |
2951 | S = ImplicitCastExpr::CreateEmpty( |
2952 | Context, |
2953 | Record[ASTStmtReader::NumExprFields], |
2954 | Record[ASTStmtReader::NumExprFields + 1]); |
2955 | break; |
2956 | |
2957 | case EXPR_CSTYLE_CAST: |
2958 | S = CStyleCastExpr::CreateEmpty( |
2959 | Context, |
2960 | Record[ASTStmtReader::NumExprFields], |
2961 | Record[ASTStmtReader::NumExprFields + 1]); |
2962 | break; |
2963 | |
2964 | case EXPR_COMPOUND_LITERAL: |
2965 | S = new (Context) CompoundLiteralExpr(Empty); |
2966 | break; |
2967 | |
2968 | case EXPR_EXT_VECTOR_ELEMENT: |
2969 | S = new (Context) ExtVectorElementExpr(Empty); |
2970 | break; |
2971 | |
2972 | case EXPR_INIT_LIST: |
2973 | S = new (Context) InitListExpr(Empty); |
2974 | break; |
2975 | |
2976 | case EXPR_DESIGNATED_INIT: |
2977 | S = DesignatedInitExpr::CreateEmpty(Context, |
2978 | Record[ASTStmtReader::NumExprFields] - 1); |
2979 | |
2980 | break; |
2981 | |
2982 | case EXPR_DESIGNATED_INIT_UPDATE: |
2983 | S = new (Context) DesignatedInitUpdateExpr(Empty); |
2984 | break; |
2985 | |
2986 | case EXPR_IMPLICIT_VALUE_INIT: |
2987 | S = new (Context) ImplicitValueInitExpr(Empty); |
2988 | break; |
2989 | |
2990 | case EXPR_NO_INIT: |
2991 | S = new (Context) NoInitExpr(Empty); |
2992 | break; |
2993 | |
2994 | case EXPR_ARRAY_INIT_LOOP: |
2995 | S = new (Context) ArrayInitLoopExpr(Empty); |
2996 | break; |
2997 | |
2998 | case EXPR_ARRAY_INIT_INDEX: |
2999 | S = new (Context) ArrayInitIndexExpr(Empty); |
3000 | break; |
3001 | |
3002 | case EXPR_VA_ARG: |
3003 | S = new (Context) VAArgExpr(Empty); |
3004 | break; |
3005 | |
3006 | case EXPR_SOURCE_LOC: |
3007 | S = new (Context) SourceLocExpr(Empty); |
3008 | break; |
3009 | |
3010 | case EXPR_ADDR_LABEL: |
3011 | S = new (Context) AddrLabelExpr(Empty); |
3012 | break; |
3013 | |
3014 | case EXPR_STMT: |
3015 | S = new (Context) StmtExpr(Empty); |
3016 | break; |
3017 | |
3018 | case EXPR_CHOOSE: |
3019 | S = new (Context) ChooseExpr(Empty); |
3020 | break; |
3021 | |
3022 | case EXPR_GNU_NULL: |
3023 | S = new (Context) GNUNullExpr(Empty); |
3024 | break; |
3025 | |
3026 | case EXPR_SHUFFLE_VECTOR: |
3027 | S = new (Context) ShuffleVectorExpr(Empty); |
3028 | break; |
3029 | |
3030 | case EXPR_CONVERT_VECTOR: |
3031 | S = new (Context) ConvertVectorExpr(Empty); |
3032 | break; |
3033 | |
3034 | case EXPR_BLOCK: |
3035 | S = new (Context) BlockExpr(Empty); |
3036 | break; |
3037 | |
3038 | case EXPR_GENERIC_SELECTION: |
3039 | S = GenericSelectionExpr::CreateEmpty( |
3040 | Context, |
3041 | Record[ASTStmtReader::NumExprFields]); |
3042 | break; |
3043 | |
3044 | case EXPR_OBJC_STRING_LITERAL: |
3045 | S = new (Context) ObjCStringLiteral(Empty); |
3046 | break; |
3047 | |
3048 | case EXPR_OBJC_BOXED_EXPRESSION: |
3049 | S = new (Context) ObjCBoxedExpr(Empty); |
3050 | break; |
3051 | |
3052 | case EXPR_OBJC_ARRAY_LITERAL: |
3053 | S = ObjCArrayLiteral::CreateEmpty(Context, |
3054 | Record[ASTStmtReader::NumExprFields]); |
3055 | break; |
3056 | |
3057 | case EXPR_OBJC_DICTIONARY_LITERAL: |
3058 | S = ObjCDictionaryLiteral::CreateEmpty(Context, |
3059 | Record[ASTStmtReader::NumExprFields], |
3060 | Record[ASTStmtReader::NumExprFields + 1]); |
3061 | break; |
3062 | |
3063 | case EXPR_OBJC_ENCODE: |
3064 | S = new (Context) ObjCEncodeExpr(Empty); |
3065 | break; |
3066 | |
3067 | case EXPR_OBJC_SELECTOR_EXPR: |
3068 | S = new (Context) ObjCSelectorExpr(Empty); |
3069 | break; |
3070 | |
3071 | case EXPR_OBJC_PROTOCOL_EXPR: |
3072 | S = new (Context) ObjCProtocolExpr(Empty); |
3073 | break; |
3074 | |
3075 | case EXPR_OBJC_IVAR_REF_EXPR: |
3076 | S = new (Context) ObjCIvarRefExpr(Empty); |
3077 | break; |
3078 | |
3079 | case EXPR_OBJC_PROPERTY_REF_EXPR: |
3080 | S = new (Context) ObjCPropertyRefExpr(Empty); |
3081 | break; |
3082 | |
3083 | case EXPR_OBJC_SUBSCRIPT_REF_EXPR: |
3084 | S = new (Context) ObjCSubscriptRefExpr(Empty); |
3085 | break; |
3086 | |
3087 | case EXPR_OBJC_KVC_REF_EXPR: |
3088 | llvm_unreachable("mismatching AST file"); |
3089 | |
3090 | case EXPR_OBJC_MESSAGE_EXPR: |
3091 | S = ObjCMessageExpr::CreateEmpty(Context, |
3092 | Record[ASTStmtReader::NumExprFields], |
3093 | Record[ASTStmtReader::NumExprFields + 1]); |
3094 | break; |
3095 | |
3096 | case EXPR_OBJC_ISA: |
3097 | S = new (Context) ObjCIsaExpr(Empty); |
3098 | break; |
3099 | |
3100 | case EXPR_OBJC_INDIRECT_COPY_RESTORE: |
3101 | S = new (Context) ObjCIndirectCopyRestoreExpr(Empty); |
3102 | break; |
3103 | |
3104 | case EXPR_OBJC_BRIDGED_CAST: |
3105 | S = new (Context) ObjCBridgedCastExpr(Empty); |
3106 | break; |
3107 | |
3108 | case STMT_OBJC_FOR_COLLECTION: |
3109 | S = new (Context) ObjCForCollectionStmt(Empty); |
3110 | break; |
3111 | |
3112 | case STMT_OBJC_CATCH: |
3113 | S = new (Context) ObjCAtCatchStmt(Empty); |
3114 | break; |
3115 | |
3116 | case STMT_OBJC_FINALLY: |
3117 | S = new (Context) ObjCAtFinallyStmt(Empty); |
3118 | break; |
3119 | |
3120 | case STMT_OBJC_AT_TRY: |
3121 | S = ObjCAtTryStmt::CreateEmpty(Context, |
3122 | Record[ASTStmtReader::NumStmtFields], |
3123 | Record[ASTStmtReader::NumStmtFields + 1]); |
3124 | break; |
3125 | |
3126 | case STMT_OBJC_AT_SYNCHRONIZED: |
3127 | S = new (Context) ObjCAtSynchronizedStmt(Empty); |
3128 | break; |
3129 | |
3130 | case STMT_OBJC_AT_THROW: |
3131 | S = new (Context) ObjCAtThrowStmt(Empty); |
3132 | break; |
3133 | |
3134 | case STMT_OBJC_AUTORELEASE_POOL: |
3135 | S = new (Context) ObjCAutoreleasePoolStmt(Empty); |
3136 | break; |
3137 | |
3138 | case EXPR_OBJC_BOOL_LITERAL: |
3139 | S = new (Context) ObjCBoolLiteralExpr(Empty); |
3140 | break; |
3141 | |
3142 | case EXPR_OBJC_AVAILABILITY_CHECK: |
3143 | S = new (Context) ObjCAvailabilityCheckExpr(Empty); |
3144 | break; |
3145 | |
3146 | case STMT_SEH_LEAVE: |
3147 | S = new (Context) SEHLeaveStmt(Empty); |
3148 | break; |
3149 | |
3150 | case STMT_SEH_EXCEPT: |
3151 | S = new (Context) SEHExceptStmt(Empty); |
3152 | break; |
3153 | |
3154 | case STMT_SEH_FINALLY: |
3155 | S = new (Context) SEHFinallyStmt(Empty); |
3156 | break; |
3157 | |
3158 | case STMT_SEH_TRY: |
3159 | S = new (Context) SEHTryStmt(Empty); |
3160 | break; |
3161 | |
3162 | case STMT_CXX_CATCH: |
3163 | S = new (Context) CXXCatchStmt(Empty); |
3164 | break; |
3165 | |
3166 | case STMT_CXX_TRY: |
3167 | S = CXXTryStmt::Create(Context, Empty, |
3168 | Record[ASTStmtReader::NumStmtFields]); |
3169 | break; |
3170 | |
3171 | case STMT_CXX_FOR_RANGE: |
3172 | S = new (Context) CXXForRangeStmt(Empty); |
3173 | break; |
3174 | |
3175 | case STMT_MS_DEPENDENT_EXISTS: |
3176 | S = new (Context) MSDependentExistsStmt(SourceLocation(), true, |
3177 | NestedNameSpecifierLoc(), |
3178 | DeclarationNameInfo(), |
3179 | nullptr); |
3180 | break; |
3181 | |
3182 | case STMT_OMP_CANONICAL_LOOP: |
3183 | S = OMPCanonicalLoop::createEmpty(Context); |
3184 | break; |
3185 | |
3186 | case STMT_OMP_PARALLEL_DIRECTIVE: |
3187 | S = |
3188 | OMPParallelDirective::CreateEmpty(Context, |
3189 | Record[ASTStmtReader::NumStmtFields], |
3190 | Empty); |
3191 | break; |
3192 | |
3193 | case STMT_OMP_SIMD_DIRECTIVE: { |
3194 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3195 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3196 | S = OMPSimdDirective::CreateEmpty(Context, NumClauses, |
3197 | CollapsedNum, Empty); |
3198 | break; |
3199 | } |
3200 | |
3201 | case STMT_OMP_TILE_DIRECTIVE: { |
3202 | unsigned NumLoops = Record[ASTStmtReader::NumStmtFields]; |
3203 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3204 | S = OMPTileDirective::CreateEmpty(Context, NumClauses, NumLoops); |
3205 | break; |
3206 | } |
3207 | |
3208 | case STMT_OMP_UNROLL_DIRECTIVE: { |
3209 | assert(Record[ASTStmtReader::NumStmtFields] == 1 && "Unroll directive accepts only a single loop"); |
3210 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3211 | S = OMPUnrollDirective::CreateEmpty(Context, NumClauses); |
3212 | break; |
3213 | } |
3214 | |
3215 | case STMT_OMP_FOR_DIRECTIVE: { |
3216 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3217 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3218 | S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum, |
3219 | Empty); |
3220 | break; |
3221 | } |
3222 | |
3223 | case STMT_OMP_FOR_SIMD_DIRECTIVE: { |
3224 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3225 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3226 | S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum, |
3227 | Empty); |
3228 | break; |
3229 | } |
3230 | |
3231 | case STMT_OMP_SECTIONS_DIRECTIVE: |
3232 | S = OMPSectionsDirective::CreateEmpty( |
3233 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3234 | break; |
3235 | |
3236 | case STMT_OMP_SECTION_DIRECTIVE: |
3237 | S = OMPSectionDirective::CreateEmpty(Context, Empty); |
3238 | break; |
3239 | |
3240 | case STMT_OMP_SINGLE_DIRECTIVE: |
3241 | S = OMPSingleDirective::CreateEmpty( |
3242 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3243 | break; |
3244 | |
3245 | case STMT_OMP_MASTER_DIRECTIVE: |
3246 | S = OMPMasterDirective::CreateEmpty(Context, Empty); |
3247 | break; |
3248 | |
3249 | case STMT_OMP_CRITICAL_DIRECTIVE: |
3250 | S = OMPCriticalDirective::CreateEmpty( |
3251 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3252 | break; |
3253 | |
3254 | case STMT_OMP_PARALLEL_FOR_DIRECTIVE: { |
3255 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3256 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3257 | S = OMPParallelForDirective::CreateEmpty(Context, NumClauses, |
3258 | CollapsedNum, Empty); |
3259 | break; |
3260 | } |
3261 | |
3262 | case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: { |
3263 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3264 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3265 | S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses, |
3266 | CollapsedNum, Empty); |
3267 | break; |
3268 | } |
3269 | |
3270 | case STMT_OMP_PARALLEL_MASTER_DIRECTIVE: |
3271 | S = OMPParallelMasterDirective::CreateEmpty( |
3272 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3273 | break; |
3274 | |
3275 | case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE: |
3276 | S = OMPParallelSectionsDirective::CreateEmpty( |
3277 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3278 | break; |
3279 | |
3280 | case STMT_OMP_TASK_DIRECTIVE: |
3281 | S = OMPTaskDirective::CreateEmpty( |
3282 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3283 | break; |
3284 | |
3285 | case STMT_OMP_TASKYIELD_DIRECTIVE: |
3286 | S = OMPTaskyieldDirective::CreateEmpty(Context, Empty); |
3287 | break; |
3288 | |
3289 | case STMT_OMP_BARRIER_DIRECTIVE: |
3290 | S = OMPBarrierDirective::CreateEmpty(Context, Empty); |
3291 | break; |
3292 | |
3293 | case STMT_OMP_TASKWAIT_DIRECTIVE: |
3294 | S = OMPTaskwaitDirective::CreateEmpty(Context, Empty); |
3295 | break; |
3296 | |
3297 | case STMT_OMP_TASKGROUP_DIRECTIVE: |
3298 | S = OMPTaskgroupDirective::CreateEmpty( |
3299 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3300 | break; |
3301 | |
3302 | case STMT_OMP_FLUSH_DIRECTIVE: |
3303 | S = OMPFlushDirective::CreateEmpty( |
3304 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3305 | break; |
3306 | |
3307 | case STMT_OMP_DEPOBJ_DIRECTIVE: |
3308 | S = OMPDepobjDirective::CreateEmpty( |
3309 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3310 | break; |
3311 | |
3312 | case STMT_OMP_SCAN_DIRECTIVE: |
3313 | S = OMPScanDirective::CreateEmpty( |
3314 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3315 | break; |
3316 | |
3317 | case STMT_OMP_ORDERED_DIRECTIVE: { |
3318 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; |
3319 | bool HasAssociatedStmt = Record[ASTStmtReader::NumStmtFields + 2]; |
3320 | S = OMPOrderedDirective::CreateEmpty(Context, NumClauses, |
3321 | !HasAssociatedStmt, Empty); |
3322 | break; |
3323 | } |
3324 | |
3325 | case STMT_OMP_ATOMIC_DIRECTIVE: |
3326 | S = OMPAtomicDirective::CreateEmpty( |
3327 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3328 | break; |
3329 | |
3330 | case STMT_OMP_TARGET_DIRECTIVE: |
3331 | S = OMPTargetDirective::CreateEmpty( |
3332 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3333 | break; |
3334 | |
3335 | case STMT_OMP_TARGET_DATA_DIRECTIVE: |
3336 | S = OMPTargetDataDirective::CreateEmpty( |
3337 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3338 | break; |
3339 | |
3340 | case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE: |
3341 | S = OMPTargetEnterDataDirective::CreateEmpty( |
3342 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3343 | break; |
3344 | |
3345 | case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE: |
3346 | S = OMPTargetExitDataDirective::CreateEmpty( |
3347 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3348 | break; |
3349 | |
3350 | case STMT_OMP_TARGET_PARALLEL_DIRECTIVE: |
3351 | S = OMPTargetParallelDirective::CreateEmpty( |
3352 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3353 | break; |
3354 | |
3355 | case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: { |
3356 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3357 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3358 | S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses, |
3359 | CollapsedNum, Empty); |
3360 | break; |
3361 | } |
3362 | |
3363 | case STMT_OMP_TARGET_UPDATE_DIRECTIVE: |
3364 | S = OMPTargetUpdateDirective::CreateEmpty( |
3365 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3366 | break; |
3367 | |
3368 | case STMT_OMP_TEAMS_DIRECTIVE: |
3369 | S = OMPTeamsDirective::CreateEmpty( |
3370 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3371 | break; |
3372 | |
3373 | case STMT_OMP_CANCELLATION_POINT_DIRECTIVE: |
3374 | S = OMPCancellationPointDirective::CreateEmpty(Context, Empty); |
3375 | break; |
3376 | |
3377 | case STMT_OMP_CANCEL_DIRECTIVE: |
3378 | S = OMPCancelDirective::CreateEmpty( |
3379 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3380 | break; |
3381 | |
3382 | case STMT_OMP_TASKLOOP_DIRECTIVE: { |
3383 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3384 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3385 | S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum, |
3386 | Empty); |
3387 | break; |
3388 | } |
3389 | |
3390 | case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: { |
3391 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3392 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3393 | S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses, |
3394 | CollapsedNum, Empty); |
3395 | break; |
3396 | } |
3397 | |
3398 | case STMT_OMP_MASTER_TASKLOOP_DIRECTIVE: { |
3399 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3400 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3401 | S = OMPMasterTaskLoopDirective::CreateEmpty(Context, NumClauses, |
3402 | CollapsedNum, Empty); |
3403 | break; |
3404 | } |
3405 | |
3406 | case STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE: { |
3407 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3408 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3409 | S = OMPMasterTaskLoopSimdDirective::CreateEmpty(Context, NumClauses, |
3410 | CollapsedNum, Empty); |
3411 | break; |
3412 | } |
3413 | |
3414 | case STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE: { |
3415 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3416 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3417 | S = OMPParallelMasterTaskLoopDirective::CreateEmpty(Context, NumClauses, |
3418 | CollapsedNum, Empty); |
3419 | break; |
3420 | } |
3421 | |
3422 | case STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE: { |
3423 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3424 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3425 | S = OMPParallelMasterTaskLoopSimdDirective::CreateEmpty( |
3426 | Context, NumClauses, CollapsedNum, Empty); |
3427 | break; |
3428 | } |
3429 | |
3430 | case STMT_OMP_DISTRIBUTE_DIRECTIVE: { |
3431 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3432 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3433 | S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum, |
3434 | Empty); |
3435 | break; |
3436 | } |
3437 | |
3438 | case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { |
3439 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3440 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3441 | S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses, |
3442 | CollapsedNum, Empty); |
3443 | break; |
3444 | } |
3445 | |
3446 | case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { |
3447 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3448 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3449 | S = OMPDistributeParallelForSimdDirective::CreateEmpty(Context, NumClauses, |
3450 | CollapsedNum, |
3451 | Empty); |
3452 | break; |
3453 | } |
3454 | |
3455 | case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: { |
3456 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3457 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3458 | S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses, |
3459 | CollapsedNum, Empty); |
3460 | break; |
3461 | } |
3462 | |
3463 | case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: { |
3464 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3465 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3466 | S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses, |
3467 | CollapsedNum, Empty); |
3468 | break; |
3469 | } |
3470 | |
3471 | case STMT_OMP_TARGET_SIMD_DIRECTIVE: { |
3472 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3473 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3474 | S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum, |
3475 | Empty); |
3476 | break; |
3477 | } |
3478 | |
3479 | case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: { |
3480 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3481 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3482 | S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses, |
3483 | CollapsedNum, Empty); |
3484 | break; |
3485 | } |
3486 | |
3487 | case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: { |
3488 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3489 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3490 | S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses, |
3491 | CollapsedNum, Empty); |
3492 | break; |
3493 | } |
3494 | |
3495 | case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { |
3496 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3497 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3498 | S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty( |
3499 | Context, NumClauses, CollapsedNum, Empty); |
3500 | break; |
3501 | } |
3502 | |
3503 | case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { |
3504 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3505 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3506 | S = OMPTeamsDistributeParallelForDirective::CreateEmpty( |
3507 | Context, NumClauses, CollapsedNum, Empty); |
3508 | break; |
3509 | } |
3510 | |
3511 | case STMT_OMP_TARGET_TEAMS_DIRECTIVE: |
3512 | S = OMPTargetTeamsDirective::CreateEmpty( |
3513 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3514 | break; |
3515 | |
3516 | case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: { |
3517 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3518 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3519 | S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses, |
3520 | CollapsedNum, Empty); |
3521 | break; |
3522 | } |
3523 | |
3524 | case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { |
3525 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3526 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3527 | S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty( |
3528 | Context, NumClauses, CollapsedNum, Empty); |
3529 | break; |
3530 | } |
3531 | |
3532 | case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { |
3533 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3534 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3535 | S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty( |
3536 | Context, NumClauses, CollapsedNum, Empty); |
3537 | break; |
3538 | } |
3539 | |
3540 | case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: { |
3541 | unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; |
3542 | unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; |
3543 | S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty( |
3544 | Context, NumClauses, CollapsedNum, Empty); |
3545 | break; |
3546 | } |
3547 | |
3548 | case STMT_OMP_INTEROP_DIRECTIVE: |
3549 | S = OMPInteropDirective::CreateEmpty( |
3550 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3551 | break; |
3552 | |
3553 | case STMT_OMP_DISPATCH_DIRECTIVE: |
3554 | S = OMPDispatchDirective::CreateEmpty( |
3555 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3556 | break; |
3557 | |
3558 | case STMT_OMP_MASKED_DIRECTIVE: |
3559 | S = OMPMaskedDirective::CreateEmpty( |
3560 | Context, Record[ASTStmtReader::NumStmtFields], Empty); |
3561 | break; |
3562 | |
3563 | case EXPR_CXX_OPERATOR_CALL: |
3564 | S = CXXOperatorCallExpr::CreateEmpty( |
3565 | Context, Record[ASTStmtReader::NumExprFields], |
3566 | Record[ASTStmtReader::NumExprFields + 1], Empty); |
3567 | break; |
3568 | |
3569 | case EXPR_CXX_MEMBER_CALL: |
3570 | S = CXXMemberCallExpr::CreateEmpty( |
3571 | Context, Record[ASTStmtReader::NumExprFields], |
3572 | Record[ASTStmtReader::NumExprFields + 1], Empty); |
3573 | break; |
3574 | |
3575 | case EXPR_CXX_REWRITTEN_BINARY_OPERATOR: |
3576 | S = new (Context) CXXRewrittenBinaryOperator(Empty); |
3577 | break; |
3578 | |
3579 | case EXPR_CXX_CONSTRUCT: |
3580 | S = CXXConstructExpr::CreateEmpty( |
3581 | Context, |
3582 | Record[ASTStmtReader::NumExprFields]); |
3583 | break; |
3584 | |
3585 | case EXPR_CXX_INHERITED_CTOR_INIT: |
3586 | S = new (Context) CXXInheritedCtorInitExpr(Empty); |
3587 | break; |
3588 | |
3589 | case EXPR_CXX_TEMPORARY_OBJECT: |
3590 | S = CXXTemporaryObjectExpr::CreateEmpty( |
3591 | Context, |
3592 | Record[ASTStmtReader::NumExprFields]); |
3593 | break; |
3594 | |
3595 | case EXPR_CXX_STATIC_CAST: |
3596 | S = CXXStaticCastExpr::CreateEmpty( |
3597 | Context, |
3598 | Record[ASTStmtReader::NumExprFields], |
3599 | Record[ASTStmtReader::NumExprFields + 1]); |
3600 | break; |
3601 | |
3602 | case EXPR_CXX_DYNAMIC_CAST: |
3603 | S = CXXDynamicCastExpr::CreateEmpty(Context, |
3604 | Record[ASTStmtReader::NumExprFields]); |
3605 | break; |
3606 | |
3607 | case EXPR_CXX_REINTERPRET_CAST: |
3608 | S = CXXReinterpretCastExpr::CreateEmpty(Context, |
3609 | Record[ASTStmtReader::NumExprFields]); |
3610 | break; |
3611 | |
3612 | case EXPR_CXX_CONST_CAST: |
3613 | S = CXXConstCastExpr::CreateEmpty(Context); |
3614 | break; |
3615 | |
3616 | case EXPR_CXX_ADDRSPACE_CAST: |
3617 | S = CXXAddrspaceCastExpr::CreateEmpty(Context); |
3618 | break; |
3619 | |
3620 | case EXPR_CXX_FUNCTIONAL_CAST: |
3621 | S = CXXFunctionalCastExpr::CreateEmpty( |
3622 | Context, |
3623 | Record[ASTStmtReader::NumExprFields], |
3624 | Record[ASTStmtReader::NumExprFields + 1]); |
3625 | break; |
3626 | |
3627 | case EXPR_BUILTIN_BIT_CAST: |
3628 | assert(Record[ASTStmtReader::NumExprFields] == 0 && "Wrong PathSize!"); |
3629 | S = new (Context) BuiltinBitCastExpr(Empty); |
3630 | break; |
3631 | |
3632 | case EXPR_USER_DEFINED_LITERAL: |
3633 | S = UserDefinedLiteral::CreateEmpty( |
3634 | Context, Record[ASTStmtReader::NumExprFields], |
3635 | Record[ASTStmtReader::NumExprFields + 1], Empty); |
3636 | break; |
3637 | |
3638 | case EXPR_CXX_STD_INITIALIZER_LIST: |
3639 | S = new (Context) CXXStdInitializerListExpr(Empty); |
3640 | break; |
3641 | |
3642 | case EXPR_CXX_BOOL_LITERAL: |
3643 | S = new (Context) CXXBoolLiteralExpr(Empty); |
3644 | break; |
3645 | |
3646 | case EXPR_CXX_NULL_PTR_LITERAL: |
3647 | S = new (Context) CXXNullPtrLiteralExpr(Empty); |
3648 | break; |
3649 | |
3650 | case EXPR_CXX_TYPEID_EXPR: |
3651 | S = new (Context) CXXTypeidExpr(Empty, true); |
3652 | break; |
3653 | |
3654 | case EXPR_CXX_TYPEID_TYPE: |
3655 | S = new (Context) CXXTypeidExpr(Empty, false); |
3656 | break; |
3657 | |
3658 | case EXPR_CXX_UUIDOF_EXPR: |
3659 | S = new (Context) CXXUuidofExpr(Empty, true); |
3660 | break; |
3661 | |
3662 | case EXPR_CXX_PROPERTY_REF_EXPR: |
3663 | S = new (Context) MSPropertyRefExpr(Empty); |
3664 | break; |
3665 | |
3666 | case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR: |
3667 | S = new (Context) MSPropertySubscriptExpr(Empty); |
3668 | break; |
3669 | |
3670 | case EXPR_CXX_UUIDOF_TYPE: |
3671 | S = new (Context) CXXUuidofExpr(Empty, false); |
3672 | break; |
3673 | |
3674 | case EXPR_CXX_THIS: |
3675 | S = new (Context) CXXThisExpr(Empty); |
3676 | break; |
3677 | |
3678 | case EXPR_CXX_THROW: |
3679 | S = new (Context) CXXThrowExpr(Empty); |
3680 | break; |
3681 | |
3682 | case EXPR_CXX_DEFAULT_ARG: |
3683 | S = new (Context) CXXDefaultArgExpr(Empty); |
3684 | break; |
3685 | |
3686 | case EXPR_CXX_DEFAULT_INIT: |
3687 | S = new (Context) CXXDefaultInitExpr(Empty); |
3688 | break; |
3689 | |
3690 | case EXPR_CXX_BIND_TEMPORARY: |
3691 | S = new (Context) CXXBindTemporaryExpr(Empty); |
3692 | break; |
3693 | |
3694 | case EXPR_CXX_SCALAR_VALUE_INIT: |
3695 | S = new (Context) CXXScalarValueInitExpr(Empty); |
3696 | break; |
3697 | |
3698 | case EXPR_CXX_NEW: |
3699 | S = CXXNewExpr::CreateEmpty( |
3700 | Context, |
3701 | Record[ASTStmtReader::NumExprFields], |
3702 | Record[ASTStmtReader::NumExprFields + 1], |
3703 | Record[ASTStmtReader::NumExprFields + 2], |
3704 | Record[ASTStmtReader::NumExprFields + 3]); |
3705 | break; |
3706 | |
3707 | case EXPR_CXX_DELETE: |
3708 | S = new (Context) CXXDeleteExpr(Empty); |
3709 | break; |
3710 | |
3711 | case EXPR_CXX_PSEUDO_DESTRUCTOR: |
3712 | S = new (Context) CXXPseudoDestructorExpr(Empty); |
3713 | break; |
3714 | |
3715 | case EXPR_EXPR_WITH_CLEANUPS: |
3716 | S = ExprWithCleanups::Create(Context, Empty, |
3717 | Record[ASTStmtReader::NumExprFields]); |
3718 | break; |
3719 | |
3720 | case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: |
3721 | S = CXXDependentScopeMemberExpr::CreateEmpty( |
3722 | Context, |
3723 | Record[ASTStmtReader::NumExprFields], |
3724 | Record[ASTStmtReader::NumExprFields + 1], |
3725 | |
3726 | Record[ASTStmtReader::NumExprFields + 2]); |
3727 | break; |
3728 | |
3729 | case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: |
3730 | S = DependentScopeDeclRefExpr::CreateEmpty(Context, |
3731 | Record[ASTStmtReader::NumExprFields], |
3732 | Record[ASTStmtReader::NumExprFields] |
3733 | ? Record[ASTStmtReader::NumExprFields + 1] |
3734 | : 0); |
3735 | break; |
3736 | |
3737 | case EXPR_CXX_UNRESOLVED_CONSTRUCT: |
3738 | S = CXXUnresolvedConstructExpr::CreateEmpty(Context, |
3739 | Record[ASTStmtReader::NumExprFields]); |
3740 | break; |
3741 | |
3742 | case EXPR_CXX_UNRESOLVED_MEMBER: |
3743 | S = UnresolvedMemberExpr::CreateEmpty( |
3744 | Context, |
3745 | Record[ASTStmtReader::NumExprFields], |
3746 | Record[ASTStmtReader::NumExprFields + 1], |
3747 | |
3748 | Record[ASTStmtReader::NumExprFields + 1] |
3749 | ? Record[ASTStmtReader::NumExprFields + 2] |
3750 | : 0); |
3751 | break; |
3752 | |
3753 | case EXPR_CXX_UNRESOLVED_LOOKUP: |
3754 | S = UnresolvedLookupExpr::CreateEmpty( |
3755 | Context, |
3756 | Record[ASTStmtReader::NumExprFields], |
3757 | Record[ASTStmtReader::NumExprFields + 1], |
3758 | |
3759 | Record[ASTStmtReader::NumExprFields + 1] |
3760 | ? Record[ASTStmtReader::NumExprFields + 2] |
3761 | : 0); |
3762 | break; |
3763 | |
3764 | case EXPR_TYPE_TRAIT: |
3765 | S = TypeTraitExpr::CreateDeserialized(Context, |
3766 | Record[ASTStmtReader::NumExprFields]); |
3767 | break; |
3768 | |
3769 | case EXPR_ARRAY_TYPE_TRAIT: |
3770 | S = new (Context) ArrayTypeTraitExpr(Empty); |
3771 | break; |
3772 | |
3773 | case EXPR_CXX_EXPRESSION_TRAIT: |
3774 | S = new (Context) ExpressionTraitExpr(Empty); |
3775 | break; |
3776 | |
3777 | case EXPR_CXX_NOEXCEPT: |
3778 | S = new (Context) CXXNoexceptExpr(Empty); |
3779 | break; |
3780 | |
3781 | case EXPR_PACK_EXPANSION: |
3782 | S = new (Context) PackExpansionExpr(Empty); |
3783 | break; |
3784 | |
3785 | case EXPR_SIZEOF_PACK: |
3786 | S = SizeOfPackExpr::CreateDeserialized( |
3787 | Context, |
3788 | Record[ASTStmtReader::NumExprFields]); |
3789 | break; |
3790 | |
3791 | case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM: |
3792 | S = new (Context) SubstNonTypeTemplateParmExpr(Empty); |
3793 | break; |
3794 | |
3795 | case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK: |
3796 | S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty); |
3797 | break; |
3798 | |
3799 | case EXPR_FUNCTION_PARM_PACK: |
3800 | S = FunctionParmPackExpr::CreateEmpty(Context, |
3801 | Record[ASTStmtReader::NumExprFields]); |
3802 | break; |
3803 | |
3804 | case EXPR_MATERIALIZE_TEMPORARY: |
3805 | S = new (Context) MaterializeTemporaryExpr(Empty); |
3806 | break; |
3807 | |
3808 | case EXPR_CXX_FOLD: |
3809 | S = new (Context) CXXFoldExpr(Empty); |
3810 | break; |
3811 | |
3812 | case EXPR_OPAQUE_VALUE: |
3813 | S = new (Context) OpaqueValueExpr(Empty); |
3814 | break; |
3815 | |
3816 | case EXPR_CUDA_KERNEL_CALL: |
3817 | S = CUDAKernelCallExpr::CreateEmpty( |
3818 | Context, Record[ASTStmtReader::NumExprFields], |
3819 | Record[ASTStmtReader::NumExprFields + 1], Empty); |
3820 | break; |
3821 | |
3822 | case EXPR_ASTYPE: |
3823 | S = new (Context) AsTypeExpr(Empty); |
3824 | break; |
3825 | |
3826 | case EXPR_PSEUDO_OBJECT: { |
3827 | unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields]; |
3828 | S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs); |
3829 | break; |
3830 | } |
3831 | |
3832 | case EXPR_ATOMIC: |
3833 | S = new (Context) AtomicExpr(Empty); |
3834 | break; |
3835 | |
3836 | case EXPR_LAMBDA: { |
3837 | unsigned NumCaptures = Record[ASTStmtReader::NumExprFields]; |
3838 | S = LambdaExpr::CreateDeserialized(Context, NumCaptures); |
3839 | break; |
3840 | } |
3841 | |
3842 | case STMT_COROUTINE_BODY: { |
3843 | unsigned NumParams = Record[ASTStmtReader::NumStmtFields]; |
3844 | S = CoroutineBodyStmt::Create(Context, Empty, NumParams); |
3845 | break; |
3846 | } |
3847 | |
3848 | case STMT_CORETURN: |
3849 | S = new (Context) CoreturnStmt(Empty); |
3850 | break; |
3851 | |
3852 | case EXPR_COAWAIT: |
3853 | S = new (Context) CoawaitExpr(Empty); |
3854 | break; |
3855 | |
3856 | case EXPR_COYIELD: |
3857 | S = new (Context) CoyieldExpr(Empty); |
3858 | break; |
3859 | |
3860 | case EXPR_DEPENDENT_COAWAIT: |
3861 | S = new (Context) DependentCoawaitExpr(Empty); |
3862 | break; |
3863 | |
3864 | case EXPR_CONCEPT_SPECIALIZATION: { |
3865 | unsigned numTemplateArgs = Record[ASTStmtReader::NumExprFields]; |
3866 | S = ConceptSpecializationExpr::Create(Context, Empty, numTemplateArgs); |
3867 | break; |
3868 | } |
3869 | |
3870 | case EXPR_REQUIRES: |
3871 | unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields]; |
3872 | unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1]; |
3873 | S = RequiresExpr::Create(Context, Empty, numLocalParameters, |
3874 | numRequirement); |
3875 | break; |
3876 | } |
3877 | |
3878 | |
3879 | if (Finished) |
3880 | break; |
3881 | |
3882 | ++NumStatementsRead; |
3883 | |
3884 | if (S && !IsStmtReference) { |
3885 | Reader.Visit(S); |
3886 | StmtEntries[Cursor.GetCurrentBitNo()] = S; |
3887 | } |
3888 | |
3889 | assert(Record.getIdx() == Record.size() && |
3890 | "Invalid deserialization of statement"); |
3891 | StmtStack.push_back(S); |
3892 | } |
3893 | Done: |
3894 | assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!"); |
3895 | assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"); |
3896 | return StmtStack.pop_back_val(); |
3897 | } |