1//===- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Statement/expression deserialization. This implements the
10// ASTReader::ReadStmt method.
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/StmtSYCL.h"
37#include "clang/AST/StmtVisitor.h"
38#include "clang/AST/TemplateBase.h"
39#include "clang/AST/Type.h"
40#include "clang/AST/UnresolvedSet.h"
41#include "clang/Basic/CapturedStmt.h"
42#include "clang/Basic/ExpressionTraits.h"
43#include "clang/Basic/LLVM.h"
44#include "clang/Basic/LangOptions.h"
45#include "clang/Basic/OpenMPKinds.h"
46#include "clang/Basic/SourceLocation.h"
47#include "clang/Basic/Specifiers.h"
48#include "clang/Basic/TypeTraits.h"
49#include "clang/Lex/Token.h"
50#include "clang/Serialization/ASTBitCodes.h"
51#include "clang/Serialization/ASTRecordReader.h"
52#include "llvm/ADT/DenseMap.h"
53#include "llvm/ADT/SmallVector.h"
54#include "llvm/ADT/StringRef.h"
55#include "llvm/Bitstream/BitstreamReader.h"
56#include "llvm/Support/ErrorHandling.h"
57#include <algorithm>
58#include <cassert>
59#include <cstdint>
60#include <optional>
61#include <string>
62
63using namespace clang;
64using namespace serialization;
65
66namespace clang {
67
68 class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
69 ASTRecordReader &Record;
70 llvm::BitstreamCursor &DeclsCursor;
71
72 std::optional<BitsUnpacker> CurrentUnpackingBits;
73
74 SourceLocation readSourceLocation() {
75 return Record.readSourceLocation();
76 }
77
78 SourceRange readSourceRange() {
79 return Record.readSourceRange();
80 }
81
82 std::string readString() {
83 return Record.readString();
84 }
85
86 TypeSourceInfo *readTypeSourceInfo() {
87 return Record.readTypeSourceInfo();
88 }
89
90 Decl *readDecl() {
91 return Record.readDecl();
92 }
93
94 template<typename T>
95 T *readDeclAs() {
96 return Record.readDeclAs<T>();
97 }
98
99 public:
100 ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
101 : Record(Record), DeclsCursor(Cursor) {}
102
103 /// The number of record fields required for the Stmt class
104 /// itself.
105 static const unsigned NumStmtFields = 0;
106
107 /// The number of record fields required for the Expr class
108 /// itself.
109 static const unsigned NumExprFields = NumStmtFields + 2;
110
111 /// The number of record fields required for the ObjCObjectLiteral class
112 /// itself (Expr fields + isExpressibleAsConstantInitializer).
113 static const unsigned NumObjCObjectLiteralFields = NumExprFields + 1;
114
115 /// The number of bits required for the packing bits for the Expr class.
116 static const unsigned NumExprBits = 10;
117
118 /// Read and initialize a ExplicitTemplateArgumentList structure.
119 void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
120 TemplateArgumentLoc *ArgsLocArray,
121 unsigned NumTemplateArgs);
122
123 void VisitStmt(Stmt *S);
124#define STMT(Type, Base) \
125 void Visit##Type(Type *);
126#include "clang/AST/StmtNodes.inc"
127 };
128
129} // namespace clang
130
131void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
132 TemplateArgumentLoc *ArgsLocArray,
133 unsigned NumTemplateArgs) {
134 SourceLocation TemplateKWLoc = readSourceLocation();
135 TemplateArgumentListInfo ArgInfo;
136 ArgInfo.setLAngleLoc(readSourceLocation());
137 ArgInfo.setRAngleLoc(readSourceLocation());
138 for (unsigned i = 0; i != NumTemplateArgs; ++i)
139 ArgInfo.addArgument(Loc: Record.readTemplateArgumentLoc());
140 Args.initializeFrom(TemplateKWLoc, List: ArgInfo, OutArgArray: ArgsLocArray);
141}
142
143void ASTStmtReader::VisitStmt(Stmt *S) {
144 assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
145}
146
147void ASTStmtReader::VisitNullStmt(NullStmt *S) {
148 VisitStmt(S);
149 S->setSemiLoc(readSourceLocation());
150 S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
151}
152
153void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
154 VisitStmt(S);
155 SmallVector<Stmt *, 16> Stmts;
156 unsigned NumStmts = Record.readInt();
157 unsigned HasFPFeatures = Record.readInt();
158 assert(S->hasStoredFPFeatures() == HasFPFeatures);
159 while (NumStmts--)
160 Stmts.push_back(Elt: Record.readSubStmt());
161 S->setStmts(Stmts);
162 if (HasFPFeatures)
163 S->setStoredFPFeatures(
164 FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
165 S->LBraceLoc = readSourceLocation();
166 S->RBraceLoc = readSourceLocation();
167}
168
169void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
170 VisitStmt(S);
171 Record.recordSwitchCaseID(SC: S, ID: Record.readInt());
172 S->setKeywordLoc(readSourceLocation());
173 S->setColonLoc(readSourceLocation());
174}
175
176void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
177 VisitSwitchCase(S);
178 bool CaseStmtIsGNURange = Record.readInt();
179 S->setLHS(Record.readSubExpr());
180 S->setSubStmt(Record.readSubStmt());
181 if (CaseStmtIsGNURange) {
182 S->setRHS(Record.readSubExpr());
183 S->setEllipsisLoc(readSourceLocation());
184 }
185}
186
187void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
188 VisitSwitchCase(S);
189 S->setSubStmt(Record.readSubStmt());
190}
191
192void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
193 VisitStmt(S);
194 bool IsSideEntry = Record.readInt();
195 auto *LD = readDeclAs<LabelDecl>();
196 LD->setStmt(S);
197 S->setDecl(LD);
198 S->setSubStmt(Record.readSubStmt());
199 S->setIdentLoc(readSourceLocation());
200 S->setSideEntry(IsSideEntry);
201}
202
203void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
204 VisitStmt(S);
205 // NumAttrs in AttributedStmt is set when creating an empty
206 // AttributedStmt in AttributedStmt::CreateEmpty, since it is needed
207 // to allocate the right amount of space for the trailing Attr *.
208 uint64_t NumAttrs = Record.readInt();
209 AttrVec Attrs;
210 Record.readAttributes(Attrs);
211 (void)NumAttrs;
212 assert(NumAttrs == S->AttributedStmtBits.NumAttrs);
213 assert(NumAttrs == Attrs.size());
214 std::copy(first: Attrs.begin(), last: Attrs.end(), result: S->getAttrArrayPtr());
215 S->SubStmt = Record.readSubStmt();
216 S->AttributedStmtBits.AttrLoc = readSourceLocation();
217}
218
219void ASTStmtReader::VisitIfStmt(IfStmt *S) {
220 VisitStmt(S);
221
222 CurrentUnpackingBits.emplace(args: Record.readInt());
223
224 bool HasElse = CurrentUnpackingBits->getNextBit();
225 bool HasVar = CurrentUnpackingBits->getNextBit();
226 bool HasInit = CurrentUnpackingBits->getNextBit();
227
228 S->setStatementKind(static_cast<IfStatementKind>(Record.readInt()));
229 S->setCond(Record.readSubExpr());
230 S->setThen(Record.readSubStmt());
231 if (HasElse)
232 S->setElse(Record.readSubStmt());
233 if (HasVar)
234 S->setConditionVariableDeclStmt(cast<DeclStmt>(Val: Record.readSubStmt()));
235 if (HasInit)
236 S->setInit(Record.readSubStmt());
237
238 S->setIfLoc(readSourceLocation());
239 S->setLParenLoc(readSourceLocation());
240 S->setRParenLoc(readSourceLocation());
241 if (HasElse)
242 S->setElseLoc(readSourceLocation());
243}
244
245void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
246 VisitStmt(S);
247
248 bool HasInit = Record.readInt();
249 bool HasVar = Record.readInt();
250 bool AllEnumCasesCovered = Record.readInt();
251 if (AllEnumCasesCovered)
252 S->setAllEnumCasesCovered();
253
254 S->setCond(Record.readSubExpr());
255 S->setBody(Record.readSubStmt());
256 if (HasInit)
257 S->setInit(Record.readSubStmt());
258 if (HasVar)
259 S->setConditionVariableDeclStmt(cast<DeclStmt>(Val: Record.readSubStmt()));
260
261 S->setSwitchLoc(readSourceLocation());
262 S->setLParenLoc(readSourceLocation());
263 S->setRParenLoc(readSourceLocation());
264
265 SwitchCase *PrevSC = nullptr;
266 for (auto E = Record.size(); Record.getIdx() != E; ) {
267 SwitchCase *SC = Record.getSwitchCaseWithID(ID: Record.readInt());
268 if (PrevSC)
269 PrevSC->setNextSwitchCase(SC);
270 else
271 S->setSwitchCaseList(SC);
272
273 PrevSC = SC;
274 }
275}
276
277void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
278 VisitStmt(S);
279
280 bool HasVar = Record.readInt();
281
282 S->setCond(Record.readSubExpr());
283 S->setBody(Record.readSubStmt());
284 if (HasVar)
285 S->setConditionVariableDeclStmt(cast<DeclStmt>(Val: Record.readSubStmt()));
286
287 S->setWhileLoc(readSourceLocation());
288 S->setLParenLoc(readSourceLocation());
289 S->setRParenLoc(readSourceLocation());
290}
291
292void ASTStmtReader::VisitDoStmt(DoStmt *S) {
293 VisitStmt(S);
294 S->setCond(Record.readSubExpr());
295 S->setBody(Record.readSubStmt());
296 S->setDoLoc(readSourceLocation());
297 S->setWhileLoc(readSourceLocation());
298 S->setRParenLoc(readSourceLocation());
299}
300
301void ASTStmtReader::VisitForStmt(ForStmt *S) {
302 VisitStmt(S);
303 S->setInit(Record.readSubStmt());
304 S->setCond(Record.readSubExpr());
305 S->setConditionVariableDeclStmt(cast_or_null<DeclStmt>(Val: Record.readSubStmt()));
306 S->setInc(Record.readSubExpr());
307 S->setBody(Record.readSubStmt());
308 S->setForLoc(readSourceLocation());
309 S->setLParenLoc(readSourceLocation());
310 S->setRParenLoc(readSourceLocation());
311}
312
313void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
314 VisitStmt(S);
315 S->setLabel(readDeclAs<LabelDecl>());
316 S->setGotoLoc(readSourceLocation());
317 S->setLabelLoc(readSourceLocation());
318}
319
320void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
321 VisitStmt(S);
322 S->setGotoLoc(readSourceLocation());
323 S->setStarLoc(readSourceLocation());
324 S->setTarget(Record.readSubExpr());
325}
326
327void ASTStmtReader::VisitLoopControlStmt(LoopControlStmt *S) {
328 VisitStmt(S);
329 S->setKwLoc(readSourceLocation());
330 if (Record.readBool()) {
331 S->setLabelDecl(readDeclAs<LabelDecl>());
332 S->setLabelLoc(readSourceLocation());
333 }
334}
335
336void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
337 VisitLoopControlStmt(S);
338}
339
340void ASTStmtReader::VisitBreakStmt(BreakStmt *S) { VisitLoopControlStmt(S); }
341
342void ASTStmtReader::VisitDeferStmt(DeferStmt *S) {
343 VisitStmt(S);
344 S->setDeferLoc(readSourceLocation());
345 S->setBody(Record.readSubStmt());
346}
347
348void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
349 VisitStmt(S);
350
351 bool HasNRVOCandidate = Record.readInt();
352
353 S->setRetValue(Record.readSubExpr());
354 if (HasNRVOCandidate)
355 S->setNRVOCandidate(readDeclAs<VarDecl>());
356
357 S->setReturnLoc(readSourceLocation());
358}
359
360void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
361 VisitStmt(S);
362 S->setStartLoc(readSourceLocation());
363 S->setEndLoc(readSourceLocation());
364
365 if (Record.size() - Record.getIdx() == 1) {
366 // Single declaration
367 S->setDeclGroup(DeclGroupRef(readDecl()));
368 } else {
369 SmallVector<Decl *, 16> Decls;
370 int N = Record.size() - Record.getIdx();
371 Decls.reserve(N);
372 for (int I = 0; I < N; ++I)
373 Decls.push_back(Elt: readDecl());
374 S->setDeclGroup(DeclGroupRef(DeclGroup::Create(C&: Record.getContext(),
375 Decls: Decls.data(),
376 NumDecls: Decls.size())));
377 }
378}
379
380void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
381 VisitStmt(S);
382 S->NumOutputs = Record.readInt();
383 S->NumInputs = Record.readInt();
384 S->NumClobbers = Record.readInt();
385 S->setAsmLoc(readSourceLocation());
386 S->setVolatile(Record.readInt());
387 S->setSimple(Record.readInt());
388}
389
390void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
391 VisitAsmStmt(S);
392 S->NumLabels = Record.readInt();
393 S->setRParenLoc(readSourceLocation());
394 S->setAsmStringExpr(cast_or_null<Expr>(Val: Record.readSubStmt()));
395
396 unsigned NumOutputs = S->getNumOutputs();
397 unsigned NumInputs = S->getNumInputs();
398 unsigned NumClobbers = S->getNumClobbers();
399 unsigned NumLabels = S->getNumLabels();
400
401 // Outputs and inputs
402 SmallVector<IdentifierInfo *, 16> Names;
403 SmallVector<Expr *, 16> Constraints;
404 SmallVector<Stmt*, 16> Exprs;
405 for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
406 Names.push_back(Elt: Record.readIdentifier());
407 Constraints.push_back(Elt: cast_or_null<Expr>(Val: Record.readSubStmt()));
408 Exprs.push_back(Elt: Record.readSubStmt());
409 }
410
411 // Constraints
412 SmallVector<Expr *, 16> Clobbers;
413 for (unsigned I = 0; I != NumClobbers; ++I)
414 Clobbers.push_back(Elt: cast_or_null<Expr>(Val: Record.readSubStmt()));
415
416 // Labels
417 for (unsigned I = 0, N = NumLabels; I != N; ++I) {
418 Names.push_back(Elt: Record.readIdentifier());
419 Exprs.push_back(Elt: Record.readSubStmt());
420 }
421
422 S->setOutputsAndInputsAndClobbers(C: Record.getContext(),
423 Names: Names.data(), Constraints: Constraints.data(),
424 Exprs: Exprs.data(), NumOutputs, NumInputs,
425 NumLabels,
426 Clobbers: Clobbers.data(), NumClobbers);
427}
428
429void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
430 VisitAsmStmt(S);
431 S->LBraceLoc = readSourceLocation();
432 S->EndLoc = readSourceLocation();
433 S->NumAsmToks = Record.readInt();
434 std::string AsmStr = readString();
435
436 // Read the tokens.
437 SmallVector<Token, 16> AsmToks;
438 AsmToks.reserve(N: S->NumAsmToks);
439 for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
440 AsmToks.push_back(Elt: Record.readToken());
441 }
442
443 // The calls to reserve() for the FooData vectors are mandatory to
444 // prevent dead StringRefs in the Foo vectors.
445
446 // Read the clobbers.
447 SmallVector<std::string, 16> ClobbersData;
448 SmallVector<StringRef, 16> Clobbers;
449 ClobbersData.reserve(N: S->NumClobbers);
450 Clobbers.reserve(N: S->NumClobbers);
451 for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
452 ClobbersData.push_back(Elt: readString());
453 Clobbers.push_back(Elt: ClobbersData.back());
454 }
455
456 // Read the operands.
457 unsigned NumOperands = S->NumOutputs + S->NumInputs;
458 SmallVector<Expr*, 16> Exprs;
459 SmallVector<std::string, 16> ConstraintsData;
460 SmallVector<StringRef, 16> Constraints;
461 Exprs.reserve(N: NumOperands);
462 ConstraintsData.reserve(N: NumOperands);
463 Constraints.reserve(N: NumOperands);
464 for (unsigned i = 0; i != NumOperands; ++i) {
465 Exprs.push_back(Elt: cast<Expr>(Val: Record.readSubStmt()));
466 ConstraintsData.push_back(Elt: readString());
467 Constraints.push_back(Elt: ConstraintsData.back());
468 }
469
470 S->initialize(C: Record.getContext(), AsmString: AsmStr, AsmToks,
471 Constraints, Exprs, Clobbers);
472}
473
474void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
475 VisitStmt(S);
476 assert(Record.peekInt() == S->NumParams);
477 Record.skipInts(N: 1);
478 auto *StoredStmts = S->getStoredStmts();
479 for (unsigned i = 0;
480 i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
481 StoredStmts[i] = Record.readSubStmt();
482}
483
484void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
485 VisitStmt(S);
486 S->CoreturnLoc = Record.readSourceLocation();
487 for (auto &SubStmt: S->SubStmts)
488 SubStmt = Record.readSubStmt();
489 S->IsImplicit = Record.readInt() != 0;
490}
491
492void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
493 VisitExpr(E);
494 E->KeywordLoc = readSourceLocation();
495 for (auto &SubExpr: E->SubExprs)
496 SubExpr = Record.readSubStmt();
497 E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Val: Record.readSubStmt());
498 E->setIsImplicit(Record.readInt() != 0);
499}
500
501void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
502 VisitExpr(E);
503 E->KeywordLoc = readSourceLocation();
504 for (auto &SubExpr: E->SubExprs)
505 SubExpr = Record.readSubStmt();
506 E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Val: Record.readSubStmt());
507}
508
509void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
510 VisitExpr(E);
511 E->KeywordLoc = readSourceLocation();
512 for (auto &SubExpr: E->SubExprs)
513 SubExpr = Record.readSubStmt();
514}
515
516void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
517 VisitStmt(S);
518 Record.skipInts(N: 1);
519 S->setCapturedDecl(readDeclAs<CapturedDecl>());
520 S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
521 S->setCapturedRecordDecl(readDeclAs<RecordDecl>());
522
523 // Capture inits
524 for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
525 E = S->capture_init_end();
526 I != E; ++I)
527 *I = Record.readSubExpr();
528
529 // Body
530 S->setCapturedStmt(Record.readSubStmt());
531 S->getCapturedDecl()->setBody(S->getCapturedStmt());
532
533 // Captures
534 for (auto &I : S->captures()) {
535 I.VarAndKind.setPointer(readDeclAs<VarDecl>());
536 I.VarAndKind.setInt(
537 static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
538 I.Loc = readSourceLocation();
539 }
540}
541
542void ASTStmtReader::VisitCXXReflectExpr(CXXReflectExpr *E) {
543 // TODO(Reflection): Implement this.
544 assert(false && "not implemented yet");
545}
546
547void ASTStmtReader::VisitSYCLKernelCallStmt(SYCLKernelCallStmt *S) {
548 VisitStmt(S);
549 S->setOriginalStmt(cast<CompoundStmt>(Val: Record.readSubStmt()));
550 S->setKernelLaunchStmt(cast<Stmt>(Val: Record.readSubStmt()));
551 S->setOutlinedFunctionDecl(readDeclAs<OutlinedFunctionDecl>());
552}
553
554void ASTStmtReader::VisitExpr(Expr *E) {
555 VisitStmt(S: E);
556 CurrentUnpackingBits.emplace(args: Record.readInt());
557 E->setDependence(static_cast<ExprDependence>(
558 CurrentUnpackingBits->getNextBits(/*Width=*/5)));
559 E->setValueKind(static_cast<ExprValueKind>(
560 CurrentUnpackingBits->getNextBits(/*Width=*/2)));
561 E->setObjectKind(static_cast<ExprObjectKind>(
562 CurrentUnpackingBits->getNextBits(/*Width=*/3)));
563
564 E->setType(Record.readType());
565 assert(Record.getIdx() == NumExprFields &&
566 "Incorrect expression field count");
567}
568
569void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
570 VisitExpr(E);
571
572 auto StorageKind = static_cast<ConstantResultStorageKind>(Record.readInt());
573 assert(E->getResultStorageKind() == StorageKind && "Wrong ResultKind!");
574
575 E->ConstantExprBits.APValueKind = Record.readInt();
576 E->ConstantExprBits.IsUnsigned = Record.readInt();
577 E->ConstantExprBits.BitWidth = Record.readInt();
578 E->ConstantExprBits.HasCleanup = false; // Not serialized, see below.
579 E->ConstantExprBits.IsImmediateInvocation = Record.readInt();
580
581 switch (StorageKind) {
582 case ConstantResultStorageKind::None:
583 break;
584
585 case ConstantResultStorageKind::Int64:
586 E->Int64Result() = Record.readInt();
587 break;
588
589 case ConstantResultStorageKind::APValue:
590 E->APValueResult() = Record.readAPValue();
591 if (E->APValueResult().needsCleanup()) {
592 E->ConstantExprBits.HasCleanup = true;
593 Record.getContext().addDestruction(Ptr: &E->APValueResult());
594 }
595 break;
596 }
597
598 E->setSubExpr(Record.readSubExpr());
599}
600
601void ASTStmtReader::VisitOpenACCAsteriskSizeExpr(OpenACCAsteriskSizeExpr *E) {
602 VisitExpr(E);
603 E->setAsteriskLocation(readSourceLocation());
604}
605
606void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
607 VisitExpr(E);
608
609 E->setLocation(readSourceLocation());
610 E->setLParenLocation(readSourceLocation());
611 E->setRParenLocation(readSourceLocation());
612
613 E->setTypeSourceInfo(Record.readTypeSourceInfo());
614}
615
616void ASTStmtReader::VisitUnresolvedSYCLKernelCallStmt(
617 UnresolvedSYCLKernelCallStmt *S) {
618 VisitStmt(S);
619
620 S->setOriginalStmt(cast<CompoundStmt>(Val: Record.readSubStmt()));
621 S->setKernelLaunchIdExpr(Record.readExpr());
622}
623
624void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
625 VisitExpr(E);
626 bool HasFunctionName = Record.readInt();
627 E->PredefinedExprBits.HasFunctionName = HasFunctionName;
628 E->PredefinedExprBits.Kind = Record.readInt();
629 E->PredefinedExprBits.IsTransparent = Record.readInt();
630 E->setLocation(readSourceLocation());
631 if (HasFunctionName)
632 E->setFunctionName(cast<StringLiteral>(Val: Record.readSubExpr()));
633}
634
635void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
636 VisitExpr(E);
637
638 CurrentUnpackingBits.emplace(args: Record.readInt());
639 E->DeclRefExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit();
640 E->DeclRefExprBits.RefersToEnclosingVariableOrCapture =
641 CurrentUnpackingBits->getNextBit();
642 E->DeclRefExprBits.NonOdrUseReason =
643 CurrentUnpackingBits->getNextBits(/*Width=*/2);
644 E->DeclRefExprBits.IsImmediateEscalating = CurrentUnpackingBits->getNextBit();
645 E->DeclRefExprBits.HasFoundDecl = CurrentUnpackingBits->getNextBit();
646 E->DeclRefExprBits.HasQualifier = CurrentUnpackingBits->getNextBit();
647 E->DeclRefExprBits.HasTemplateKWAndArgsInfo =
648 CurrentUnpackingBits->getNextBit();
649 E->DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter = false;
650 unsigned NumTemplateArgs = 0;
651 if (E->hasTemplateKWAndArgsInfo())
652 NumTemplateArgs = Record.readInt();
653
654 if (E->hasQualifier())
655 new (E->getTrailingObjects<NestedNameSpecifierLoc>())
656 NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
657
658 if (E->hasFoundDecl())
659 *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
660
661 if (E->hasTemplateKWAndArgsInfo())
662 ReadTemplateKWAndArgsInfo(
663 Args&: *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
664 ArgsLocArray: E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
665
666 E->D = readDeclAs<ValueDecl>();
667 E->setLocation(readSourceLocation());
668 E->DNLoc = Record.readDeclarationNameLoc(Name: E->getDecl()->getDeclName());
669}
670
671void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
672 VisitExpr(E);
673 E->setLocation(readSourceLocation());
674 E->setValue(C: Record.getContext(), Val: Record.readAPInt());
675}
676
677void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
678 VisitExpr(E);
679 E->setLocation(readSourceLocation());
680 E->setScale(Record.readInt());
681 E->setValue(C: Record.getContext(), Val: Record.readAPInt());
682}
683
684void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
685 VisitExpr(E);
686 E->setRawSemantics(
687 static_cast<llvm::APFloatBase::Semantics>(Record.readInt()));
688 E->setExact(Record.readInt());
689 E->setValue(C: Record.getContext(), Val: Record.readAPFloat(Sem: E->getSemantics()));
690 E->setLocation(readSourceLocation());
691}
692
693void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
694 VisitExpr(E);
695 E->setSubExpr(Record.readSubExpr());
696}
697
698void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
699 VisitExpr(E);
700
701 // NumConcatenated, Length and CharByteWidth are set by the empty
702 // ctor since they are needed to allocate storage for the trailing objects.
703 unsigned NumConcatenated = Record.readInt();
704 unsigned Length = Record.readInt();
705 unsigned CharByteWidth = Record.readInt();
706 assert((NumConcatenated == E->getNumConcatenated()) &&
707 "Wrong number of concatenated tokens!");
708 assert((Length == E->getLength()) && "Wrong Length!");
709 assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!");
710 E->StringLiteralBits.Kind = Record.readInt();
711 E->StringLiteralBits.IsPascal = Record.readInt();
712
713 // The character width is originally computed via mapCharByteWidth.
714 // Check that the deserialized character width is consistant with the result
715 // of calling mapCharByteWidth.
716 assert((CharByteWidth ==
717 StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(),
718 E->getKind())) &&
719 "Wrong character width!");
720
721 // Deserialize the trailing array of SourceLocation.
722 for (unsigned I = 0; I < NumConcatenated; ++I)
723 E->setStrTokenLoc(TokNum: I, L: readSourceLocation());
724
725 // Deserialize the trailing array of char holding the string data.
726 char *StrData = E->getStrDataAsChar();
727 for (unsigned I = 0; I < Length * CharByteWidth; ++I)
728 StrData[I] = Record.readInt();
729}
730
731void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
732 VisitExpr(E);
733 E->setValue(Record.readInt());
734 E->setLocation(readSourceLocation());
735 E->setKind(static_cast<CharacterLiteralKind>(Record.readInt()));
736}
737
738void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
739 VisitExpr(E);
740 E->setIsProducedByFoldExpansion(Record.readInt());
741 E->setLParen(readSourceLocation());
742 E->setRParen(readSourceLocation());
743 E->setSubExpr(Record.readSubExpr());
744}
745
746void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
747 VisitExpr(E);
748 unsigned NumExprs = Record.readInt();
749 assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
750 for (unsigned I = 0; I != NumExprs; ++I)
751 E->getTrailingObjects()[I] = Record.readSubStmt();
752 E->LParenLoc = readSourceLocation();
753 E->RParenLoc = readSourceLocation();
754}
755
756void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
757 VisitExpr(E);
758 bool hasFP_Features = CurrentUnpackingBits->getNextBit();
759 assert(hasFP_Features == E->hasStoredFPFeatures());
760 E->setSubExpr(Record.readSubExpr());
761 E->setOpcode(
762 (UnaryOperator::Opcode)CurrentUnpackingBits->getNextBits(/*Width=*/5));
763 E->setOperatorLoc(readSourceLocation());
764 E->setCanOverflow(CurrentUnpackingBits->getNextBit());
765 if (hasFP_Features)
766 E->setStoredFPFeatures(
767 FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
768}
769
770void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
771 VisitExpr(E);
772 assert(E->getNumComponents() == Record.peekInt());
773 Record.skipInts(N: 1);
774 assert(E->getNumExpressions() == Record.peekInt());
775 Record.skipInts(N: 1);
776 E->setOperatorLoc(readSourceLocation());
777 E->setRParenLoc(readSourceLocation());
778 E->setTypeSourceInfo(readTypeSourceInfo());
779 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
780 auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
781 SourceLocation Start = readSourceLocation();
782 SourceLocation End = readSourceLocation();
783 switch (Kind) {
784 case OffsetOfNode::Array:
785 E->setComponent(Idx: I, ON: OffsetOfNode(Start, Record.readInt(), End));
786 break;
787
788 case OffsetOfNode::Field:
789 E->setComponent(
790 Idx: I, ON: OffsetOfNode(Start, readDeclAs<FieldDecl>(), End));
791 break;
792
793 case OffsetOfNode::Identifier:
794 E->setComponent(
795 Idx: I,
796 ON: OffsetOfNode(Start, Record.readIdentifier(), End));
797 break;
798
799 case OffsetOfNode::Base: {
800 auto *Base = new (Record.getContext()) CXXBaseSpecifier();
801 *Base = Record.readCXXBaseSpecifier();
802 E->setComponent(Idx: I, ON: OffsetOfNode(Base));
803 break;
804 }
805 }
806 }
807
808 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
809 E->setIndexExpr(Idx: I, E: Record.readSubExpr());
810}
811
812void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
813 VisitExpr(E);
814 E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
815 if (Record.peekInt() == 0) {
816 E->setArgument(Record.readSubExpr());
817 Record.skipInts(N: 1);
818 } else {
819 E->setArgument(readTypeSourceInfo());
820 }
821 E->setOperatorLoc(readSourceLocation());
822 E->setRParenLoc(readSourceLocation());
823}
824
825static ConstraintSatisfaction
826readConstraintSatisfaction(ASTRecordReader &Record) {
827 ConstraintSatisfaction Satisfaction;
828 Satisfaction.IsSatisfied = Record.readInt();
829 Satisfaction.ContainsErrors = Record.readInt();
830 const ASTContext &C = Record.getContext();
831 if (!Satisfaction.IsSatisfied) {
832 unsigned NumDetailRecords = Record.readInt();
833 for (unsigned i = 0; i != NumDetailRecords; ++i) {
834 auto Kind = Record.readInt();
835 if (Kind == 0) {
836 SourceLocation DiagLocation = Record.readSourceLocation();
837 StringRef DiagMessage = C.backupStr(S: Record.readString());
838
839 Satisfaction.Details.emplace_back(Args: new (
840 C) ConstraintSubstitutionDiagnostic(DiagLocation, DiagMessage));
841 } else if (Kind == 1) {
842 Satisfaction.Details.emplace_back(Args: Record.readExpr());
843 } else {
844 assert(Kind == 2);
845 Satisfaction.Details.emplace_back(Args: Record.readConceptReference());
846 }
847 }
848 }
849 return Satisfaction;
850}
851
852void ASTStmtReader::VisitConceptSpecializationExpr(
853 ConceptSpecializationExpr *E) {
854 VisitExpr(E);
855 E->SpecDecl = Record.readDeclAs<ImplicitConceptSpecializationDecl>();
856 if (Record.readBool())
857 E->ConceptRef = Record.readConceptReference();
858 E->Satisfaction = E->isValueDependent() ? nullptr :
859 ASTConstraintSatisfaction::Create(C: Record.getContext(),
860 Satisfaction: readConstraintSatisfaction(Record));
861}
862
863static concepts::Requirement::SubstitutionDiagnostic *
864readSubstitutionDiagnostic(ASTRecordReader &Record) {
865 const ASTContext &C = Record.getContext();
866 StringRef SubstitutedEntity = C.backupStr(S: Record.readString());
867 SourceLocation DiagLoc = Record.readSourceLocation();
868 StringRef DiagMessage = C.backupStr(S: Record.readString());
869
870 return new (Record.getContext())
871 concepts::Requirement::SubstitutionDiagnostic{.SubstitutedEntity: SubstitutedEntity, .DiagLoc: DiagLoc,
872 .DiagMessage: DiagMessage};
873}
874
875void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
876 VisitExpr(E);
877 unsigned NumLocalParameters = Record.readInt();
878 unsigned NumRequirements = Record.readInt();
879 E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation();
880 E->RequiresExprBits.IsSatisfied = Record.readInt();
881 E->Body = Record.readDeclAs<RequiresExprBodyDecl>();
882 llvm::SmallVector<ParmVarDecl *, 4> LocalParameters;
883 for (unsigned i = 0; i < NumLocalParameters; ++i)
884 LocalParameters.push_back(Elt: cast<ParmVarDecl>(Val: Record.readDecl()));
885 std::copy(first: LocalParameters.begin(), last: LocalParameters.end(),
886 result: E->getTrailingObjects<ParmVarDecl *>());
887 llvm::SmallVector<concepts::Requirement *, 4> Requirements;
888 for (unsigned i = 0; i < NumRequirements; ++i) {
889 auto RK =
890 static_cast<concepts::Requirement::RequirementKind>(Record.readInt());
891 concepts::Requirement *R = nullptr;
892 switch (RK) {
893 case concepts::Requirement::RK_Type: {
894 auto Status =
895 static_cast<concepts::TypeRequirement::SatisfactionStatus>(
896 Record.readInt());
897 if (Status == concepts::TypeRequirement::SS_SubstitutionFailure)
898 R = new (Record.getContext())
899 concepts::TypeRequirement(readSubstitutionDiagnostic(Record));
900 else
901 R = new (Record.getContext())
902 concepts::TypeRequirement(Record.readTypeSourceInfo());
903 } break;
904 case concepts::Requirement::RK_Simple:
905 case concepts::Requirement::RK_Compound: {
906 auto Status =
907 static_cast<concepts::ExprRequirement::SatisfactionStatus>(
908 Record.readInt());
909 llvm::PointerUnion<concepts::Requirement::SubstitutionDiagnostic *,
910 Expr *> E;
911 if (Status == concepts::ExprRequirement::SS_ExprSubstitutionFailure) {
912 E = readSubstitutionDiagnostic(Record);
913 } else
914 E = Record.readExpr();
915
916 std::optional<concepts::ExprRequirement::ReturnTypeRequirement> Req;
917 ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr;
918 SourceLocation NoexceptLoc;
919 if (RK == concepts::Requirement::RK_Simple) {
920 Req.emplace();
921 } else {
922 NoexceptLoc = Record.readSourceLocation();
923 switch (/* returnTypeRequirementKind */Record.readInt()) {
924 case 0:
925 // No return type requirement.
926 Req.emplace();
927 break;
928 case 1: {
929 // type-constraint
930 TemplateParameterList *TPL = Record.readTemplateParameterList();
931 if (Status >=
932 concepts::ExprRequirement::SS_ConstraintsNotSatisfied)
933 SubstitutedConstraintExpr =
934 cast<ConceptSpecializationExpr>(Val: Record.readExpr());
935 Req.emplace(args&: TPL);
936 } break;
937 case 2:
938 // Substitution failure
939 Req.emplace(args: readSubstitutionDiagnostic(Record));
940 break;
941 }
942 }
943 if (Expr *Ex = E.dyn_cast<Expr *>())
944 R = new (Record.getContext()) concepts::ExprRequirement(
945 Ex, RK == concepts::Requirement::RK_Simple, NoexceptLoc,
946 std::move(*Req), Status, SubstitutedConstraintExpr);
947 else
948 R = new (Record.getContext()) concepts::ExprRequirement(
949 cast<concepts::Requirement::SubstitutionDiagnostic *>(Val&: E),
950 RK == concepts::Requirement::RK_Simple, NoexceptLoc,
951 std::move(*Req));
952 } break;
953 case concepts::Requirement::RK_Nested: {
954 ASTContext &C = Record.getContext();
955 bool HasInvalidConstraint = Record.readInt();
956 if (HasInvalidConstraint) {
957 StringRef InvalidConstraint = C.backupStr(S: Record.readString());
958 R = new (C) concepts::NestedRequirement(
959 Record.getContext(), InvalidConstraint,
960 readConstraintSatisfaction(Record));
961 break;
962 }
963 Expr *E = Record.readExpr();
964 if (E->isInstantiationDependent())
965 R = new (C) concepts::NestedRequirement(E);
966 else
967 R = new (C) concepts::NestedRequirement(
968 C, E, readConstraintSatisfaction(Record));
969 } break;
970 }
971 if (!R)
972 continue;
973 Requirements.push_back(Elt: R);
974 }
975 std::copy(first: Requirements.begin(), last: Requirements.end(),
976 result: E->getTrailingObjects<concepts::Requirement *>());
977 E->LParenLoc = Record.readSourceLocation();
978 E->RParenLoc = Record.readSourceLocation();
979 E->RBraceLoc = Record.readSourceLocation();
980}
981
982void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
983 VisitExpr(E);
984 E->setLHS(Record.readSubExpr());
985 E->setRHS(Record.readSubExpr());
986 E->setRBracketLoc(readSourceLocation());
987}
988
989void ASTStmtReader::VisitMatrixSingleSubscriptExpr(
990 MatrixSingleSubscriptExpr *E) {
991 VisitExpr(E);
992 E->setBase(Record.readSubExpr());
993 E->setRowIdx(Record.readSubExpr());
994 E->setRBracketLoc(readSourceLocation());
995}
996
997void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
998 VisitExpr(E);
999 E->setBase(Record.readSubExpr());
1000 E->setRowIdx(Record.readSubExpr());
1001 E->setColumnIdx(Record.readSubExpr());
1002 E->setRBracketLoc(readSourceLocation());
1003}
1004
1005void ASTStmtReader::VisitArraySectionExpr(ArraySectionExpr *E) {
1006 VisitExpr(E);
1007 E->ASType = Record.readEnum<ArraySectionExpr::ArraySectionType>();
1008
1009 E->setBase(Record.readSubExpr());
1010 E->setLowerBound(Record.readSubExpr());
1011 E->setLength(Record.readSubExpr());
1012
1013 if (E->isOMPArraySection())
1014 E->setStride(Record.readSubExpr());
1015
1016 E->setColonLocFirst(readSourceLocation());
1017
1018 if (E->isOMPArraySection())
1019 E->setColonLocSecond(readSourceLocation());
1020
1021 E->setRBracketLoc(readSourceLocation());
1022}
1023
1024void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
1025 VisitExpr(E);
1026 unsigned NumDims = Record.readInt();
1027 E->setBase(Record.readSubExpr());
1028 SmallVector<Expr *, 4> Dims(NumDims);
1029 for (unsigned I = 0; I < NumDims; ++I)
1030 Dims[I] = Record.readSubExpr();
1031 E->setDimensions(Dims);
1032 SmallVector<SourceRange, 4> SRs(NumDims);
1033 for (unsigned I = 0; I < NumDims; ++I)
1034 SRs[I] = readSourceRange();
1035 E->setBracketsRanges(SRs);
1036 E->setLParenLoc(readSourceLocation());
1037 E->setRParenLoc(readSourceLocation());
1038}
1039
1040void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
1041 VisitExpr(E);
1042 unsigned NumIters = Record.readInt();
1043 E->setIteratorKwLoc(readSourceLocation());
1044 E->setLParenLoc(readSourceLocation());
1045 E->setRParenLoc(readSourceLocation());
1046 for (unsigned I = 0; I < NumIters; ++I) {
1047 E->setIteratorDeclaration(I, D: Record.readDeclRef());
1048 E->setAssignmentLoc(I, Loc: readSourceLocation());
1049 Expr *Begin = Record.readSubExpr();
1050 Expr *End = Record.readSubExpr();
1051 Expr *Step = Record.readSubExpr();
1052 SourceLocation ColonLoc = readSourceLocation();
1053 SourceLocation SecColonLoc;
1054 if (Step)
1055 SecColonLoc = readSourceLocation();
1056 E->setIteratorRange(I, Begin, ColonLoc, End, SecondColonLoc: SecColonLoc, Step);
1057 // Deserialize helpers
1058 OMPIteratorHelperData HD;
1059 HD.CounterVD = cast_or_null<VarDecl>(Val: Record.readDeclRef());
1060 HD.Upper = Record.readSubExpr();
1061 HD.Update = Record.readSubExpr();
1062 HD.CounterUpdate = Record.readSubExpr();
1063 E->setHelper(I, D: HD);
1064 }
1065}
1066
1067void ASTStmtReader::VisitCallExpr(CallExpr *E) {
1068 VisitExpr(E);
1069
1070 unsigned NumArgs = Record.readInt();
1071 CurrentUnpackingBits.emplace(args: Record.readInt());
1072 E->setADLCallKind(
1073 static_cast<CallExpr::ADLCallKind>(CurrentUnpackingBits->getNextBit()));
1074 bool HasFPFeatures = CurrentUnpackingBits->getNextBit();
1075 E->setCoroElideSafe(CurrentUnpackingBits->getNextBit());
1076 E->setUsesMemberSyntax(CurrentUnpackingBits->getNextBit());
1077 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1078 E->setRParenLoc(readSourceLocation());
1079 E->setCallee(Record.readSubExpr());
1080 for (unsigned I = 0; I != NumArgs; ++I)
1081 E->setArg(Arg: I, ArgExpr: Record.readSubExpr());
1082
1083 if (HasFPFeatures)
1084 E->setStoredFPFeatures(
1085 FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
1086
1087 if (E->getStmtClass() == Stmt::CallExprClass)
1088 E->updateTrailingSourceLoc();
1089}
1090
1091void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1092 VisitCallExpr(E);
1093}
1094
1095void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
1096 VisitExpr(E);
1097
1098 CurrentUnpackingBits.emplace(args: Record.readInt());
1099 bool HasQualifier = CurrentUnpackingBits->getNextBit();
1100 bool HasFoundDecl = CurrentUnpackingBits->getNextBit();
1101 bool HasTemplateInfo = CurrentUnpackingBits->getNextBit();
1102 unsigned NumTemplateArgs = Record.readInt();
1103
1104 E->Base = Record.readSubExpr();
1105 E->MemberDecl = Record.readDeclAs<ValueDecl>();
1106 E->MemberDNLoc = Record.readDeclarationNameLoc(Name: E->MemberDecl->getDeclName());
1107 E->MemberLoc = Record.readSourceLocation();
1108 E->MemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit();
1109 E->MemberExprBits.HasQualifier = HasQualifier;
1110 E->MemberExprBits.HasFoundDecl = HasFoundDecl;
1111 E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
1112 E->MemberExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit();
1113 E->MemberExprBits.NonOdrUseReason =
1114 CurrentUnpackingBits->getNextBits(/*Width=*/2);
1115 E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
1116
1117 if (HasQualifier)
1118 new (E->getTrailingObjects<NestedNameSpecifierLoc>())
1119 NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
1120
1121 if (HasFoundDecl) {
1122 auto *FoundD = Record.readDeclAs<NamedDecl>();
1123 auto AS = (AccessSpecifier)CurrentUnpackingBits->getNextBits(/*Width=*/2);
1124 *E->getTrailingObjects<DeclAccessPair>() = DeclAccessPair::make(D: FoundD, AS);
1125 }
1126
1127 if (HasTemplateInfo)
1128 ReadTemplateKWAndArgsInfo(
1129 Args&: *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1130 ArgsLocArray: E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1131}
1132
1133void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
1134 VisitExpr(E);
1135 E->setBase(Record.readSubExpr());
1136 E->setIsaMemberLoc(readSourceLocation());
1137 E->setOpLoc(readSourceLocation());
1138 E->setArrow(Record.readInt());
1139}
1140
1141void ASTStmtReader::
1142VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1143 VisitExpr(E);
1144 E->Operand = Record.readSubExpr();
1145 E->setShouldCopy(Record.readInt());
1146}
1147
1148void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1149 VisitExplicitCastExpr(E);
1150 E->LParenLoc = readSourceLocation();
1151 E->BridgeKeywordLoc = readSourceLocation();
1152 E->Kind = Record.readInt();
1153}
1154
1155void ASTStmtReader::VisitCastExpr(CastExpr *E) {
1156 VisitExpr(E);
1157 unsigned NumBaseSpecs = Record.readInt();
1158 assert(NumBaseSpecs == E->path_size());
1159
1160 CurrentUnpackingBits.emplace(args: Record.readInt());
1161 E->setCastKind((CastKind)CurrentUnpackingBits->getNextBits(/*Width=*/7));
1162 unsigned HasFPFeatures = CurrentUnpackingBits->getNextBit();
1163 assert(E->hasStoredFPFeatures() == HasFPFeatures);
1164
1165 E->setSubExpr(Record.readSubExpr());
1166
1167 CastExpr::path_iterator BaseI = E->path_begin();
1168 while (NumBaseSpecs--) {
1169 auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
1170 *BaseSpec = Record.readCXXBaseSpecifier();
1171 *BaseI++ = BaseSpec;
1172 }
1173 if (HasFPFeatures)
1174 *E->getTrailingFPFeatures() =
1175 FPOptionsOverride::getFromOpaqueInt(I: Record.readInt());
1176}
1177
1178void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
1179 VisitExpr(E);
1180 CurrentUnpackingBits.emplace(args: Record.readInt());
1181 E->setOpcode(
1182 (BinaryOperator::Opcode)CurrentUnpackingBits->getNextBits(/*Width=*/6));
1183 bool hasFP_Features = CurrentUnpackingBits->getNextBit();
1184 E->setHasStoredFPFeatures(hasFP_Features);
1185 E->setExcludedOverflowPattern(CurrentUnpackingBits->getNextBit());
1186 E->setLHS(Record.readSubExpr());
1187 E->setRHS(Record.readSubExpr());
1188 E->setOperatorLoc(readSourceLocation());
1189 if (hasFP_Features)
1190 E->setStoredFPFeatures(
1191 FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
1192}
1193
1194void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1195 VisitBinaryOperator(E);
1196 E->setComputationLHSType(Record.readType());
1197 E->setComputationResultType(Record.readType());
1198}
1199
1200void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
1201 VisitExpr(E);
1202 E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
1203 E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
1204 E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
1205 E->QuestionLoc = readSourceLocation();
1206 E->ColonLoc = readSourceLocation();
1207}
1208
1209void
1210ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1211 VisitExpr(E);
1212 E->OpaqueValue = cast<OpaqueValueExpr>(Val: Record.readSubExpr());
1213 E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
1214 E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
1215 E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
1216 E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
1217 E->QuestionLoc = readSourceLocation();
1218 E->ColonLoc = readSourceLocation();
1219}
1220
1221void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1222 VisitCastExpr(E);
1223 E->setIsPartOfExplicitCast(CurrentUnpackingBits->getNextBit());
1224}
1225
1226void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1227 VisitCastExpr(E);
1228 E->setTypeInfoAsWritten(readTypeSourceInfo());
1229}
1230
1231void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
1232 VisitExplicitCastExpr(E);
1233 E->setLParenLoc(readSourceLocation());
1234 E->setRParenLoc(readSourceLocation());
1235}
1236
1237void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1238 VisitExpr(E);
1239 E->setLParenLoc(readSourceLocation());
1240 E->setTypeSourceInfo(readTypeSourceInfo());
1241 E->setInitializer(Record.readSubExpr());
1242 E->setFileScope(Record.readInt());
1243}
1244
1245void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1246 VisitExpr(E);
1247 E->setBase(Record.readSubExpr());
1248 E->setAccessor(Record.readIdentifier());
1249 E->setAccessorLoc(readSourceLocation());
1250}
1251
1252void ASTStmtReader::VisitMatrixElementExpr(MatrixElementExpr *E) {
1253 VisitExpr(E);
1254 E->setBase(Record.readSubExpr());
1255 E->setAccessor(Record.readIdentifier());
1256 E->setAccessorLoc(readSourceLocation());
1257}
1258
1259void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
1260 VisitExpr(E);
1261 if (auto *SyntForm = cast_or_null<InitListExpr>(Val: Record.readSubStmt()))
1262 E->setSyntacticForm(SyntForm);
1263 E->setLBraceLoc(readSourceLocation());
1264 E->setRBraceLoc(readSourceLocation());
1265 bool isArrayFiller = Record.readInt();
1266 Expr *filler = nullptr;
1267 if (isArrayFiller) {
1268 filler = Record.readSubExpr();
1269 E->ArrayFillerOrUnionFieldInit = filler;
1270 } else
1271 E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>();
1272 E->sawArrayRangeDesignator(ARD: Record.readInt());
1273 unsigned NumInits = Record.readInt();
1274 E->reserveInits(C: Record.getContext(), NumInits);
1275 if (isArrayFiller) {
1276 for (unsigned I = 0; I != NumInits; ++I) {
1277 Expr *init = Record.readSubExpr();
1278 E->updateInit(C: Record.getContext(), Init: I, expr: init ? init : filler);
1279 }
1280 } else {
1281 for (unsigned I = 0; I != NumInits; ++I)
1282 E->updateInit(C: Record.getContext(), Init: I, expr: Record.readSubExpr());
1283 }
1284 E->InitListExprBits.IsExplicit = Record.readBool();
1285}
1286
1287void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1288 using Designator = DesignatedInitExpr::Designator;
1289
1290 VisitExpr(E);
1291 unsigned NumSubExprs = Record.readInt();
1292 assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
1293 for (unsigned I = 0; I != NumSubExprs; ++I)
1294 E->setSubExpr(Idx: I, E: Record.readSubExpr());
1295 E->setEqualOrColonLoc(readSourceLocation());
1296 E->setGNUSyntax(Record.readInt());
1297
1298 SmallVector<Designator, 4> Designators;
1299 while (Record.getIdx() < Record.size()) {
1300 switch ((DesignatorTypes)Record.readInt()) {
1301 case DESIG_FIELD_DECL: {
1302 auto *Field = readDeclAs<FieldDecl>();
1303 SourceLocation DotLoc = readSourceLocation();
1304 SourceLocation FieldLoc = readSourceLocation();
1305 Designators.push_back(Elt: Designator::CreateFieldDesignator(
1306 FieldName: Field->getIdentifier(), DotLoc, FieldLoc));
1307 Designators.back().setFieldDecl(Field);
1308 break;
1309 }
1310
1311 case DESIG_FIELD_NAME: {
1312 const IdentifierInfo *Name = Record.readIdentifier();
1313 SourceLocation DotLoc = readSourceLocation();
1314 SourceLocation FieldLoc = readSourceLocation();
1315 Designators.push_back(Elt: Designator::CreateFieldDesignator(FieldName: Name, DotLoc,
1316 FieldLoc));
1317 break;
1318 }
1319
1320 case DESIG_ARRAY: {
1321 unsigned Index = Record.readInt();
1322 SourceLocation LBracketLoc = readSourceLocation();
1323 SourceLocation RBracketLoc = readSourceLocation();
1324 Designators.push_back(Elt: Designator::CreateArrayDesignator(Index,
1325 LBracketLoc,
1326 RBracketLoc));
1327 break;
1328 }
1329
1330 case DESIG_ARRAY_RANGE: {
1331 unsigned Index = Record.readInt();
1332 SourceLocation LBracketLoc = readSourceLocation();
1333 SourceLocation EllipsisLoc = readSourceLocation();
1334 SourceLocation RBracketLoc = readSourceLocation();
1335 Designators.push_back(Elt: Designator::CreateArrayRangeDesignator(
1336 Index, LBracketLoc, EllipsisLoc, RBracketLoc));
1337 break;
1338 }
1339 }
1340 }
1341 E->setDesignators(C: Record.getContext(),
1342 Desigs: Designators.data(), NumDesigs: Designators.size());
1343}
1344
1345void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1346 VisitExpr(E);
1347 E->setBase(Record.readSubExpr());
1348 E->setUpdater(Record.readSubExpr());
1349}
1350
1351void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
1352 VisitExpr(E);
1353}
1354
1355void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1356 VisitExpr(E);
1357 E->SubExprs[0] = Record.readSubExpr();
1358 E->SubExprs[1] = Record.readSubExpr();
1359}
1360
1361void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1362 VisitExpr(E);
1363}
1364
1365void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1366 VisitExpr(E);
1367}
1368
1369void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
1370 VisitExpr(E);
1371 E->setSubExpr(Record.readSubExpr());
1372 E->setWrittenTypeInfo(readTypeSourceInfo());
1373 E->setBuiltinLoc(readSourceLocation());
1374 E->setRParenLoc(readSourceLocation());
1375 E->setVarargABI(static_cast<clang::VAArgExpr::VarArgKind>(Record.readInt()));
1376}
1377
1378void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
1379 VisitExpr(E);
1380 E->ParentContext = readDeclAs<DeclContext>();
1381 E->BuiltinLoc = readSourceLocation();
1382 E->RParenLoc = readSourceLocation();
1383 E->SourceLocExprBits.Kind = Record.readInt();
1384}
1385
1386void ASTStmtReader::VisitEmbedExpr(EmbedExpr *E) {
1387 VisitExpr(E);
1388 E->EmbedKeywordLoc = readSourceLocation();
1389 EmbedDataStorage *Data = new (Record.getContext()) EmbedDataStorage;
1390 Data->BinaryData = cast<StringLiteral>(Val: Record.readSubStmt());
1391 E->Data = Data;
1392 E->Begin = Record.readUInt32();
1393 E->NumOfElements = Record.readUInt32();
1394 ASTContext &Ctx = Record.getContext();
1395 E->Ctx = &Ctx;
1396 E->setType(Ctx.IntTy);
1397 E->FakeChildNode = IntegerLiteral::Create(
1398 C: Ctx, V: llvm::APInt::getZero(numBits: Ctx.getTypeSize(T: E->getType())), type: E->getType(),
1399 l: E->EmbedKeywordLoc);
1400}
1401
1402void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
1403 VisitExpr(E);
1404 E->setAmpAmpLoc(readSourceLocation());
1405 E->setLabelLoc(readSourceLocation());
1406 E->setLabel(readDeclAs<LabelDecl>());
1407}
1408
1409void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
1410 VisitExpr(E);
1411 E->setLParenLoc(readSourceLocation());
1412 E->setRParenLoc(readSourceLocation());
1413 E->setSubStmt(cast_or_null<CompoundStmt>(Val: Record.readSubStmt()));
1414 E->StmtExprBits.TemplateDepth = Record.readInt();
1415}
1416
1417void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
1418 VisitExpr(E);
1419 E->setCond(Record.readSubExpr());
1420 E->setLHS(Record.readSubExpr());
1421 E->setRHS(Record.readSubExpr());
1422 E->setBuiltinLoc(readSourceLocation());
1423 E->setRParenLoc(readSourceLocation());
1424 E->setIsConditionTrue(Record.readInt());
1425}
1426
1427void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
1428 VisitExpr(E);
1429 E->setTokenLocation(readSourceLocation());
1430}
1431
1432void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1433 VisitExpr(E);
1434 SmallVector<Expr *, 16> Exprs;
1435 unsigned NumExprs = Record.readInt();
1436 while (NumExprs--)
1437 Exprs.push_back(Elt: Record.readSubExpr());
1438 E->setExprs(C: Record.getContext(), Exprs);
1439 E->setBuiltinLoc(readSourceLocation());
1440 E->setRParenLoc(readSourceLocation());
1441}
1442
1443void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1444 VisitExpr(E);
1445 bool HasFPFeatures = CurrentUnpackingBits->getNextBit();
1446 assert(HasFPFeatures == E->hasStoredFPFeatures());
1447 E->BuiltinLoc = readSourceLocation();
1448 E->RParenLoc = readSourceLocation();
1449 E->TInfo = readTypeSourceInfo();
1450 E->SrcExpr = Record.readSubExpr();
1451 if (HasFPFeatures)
1452 E->setStoredFPFeatures(
1453 FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
1454}
1455
1456void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
1457 VisitExpr(E);
1458 E->setBlockDecl(readDeclAs<BlockDecl>());
1459}
1460
1461void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1462 VisitExpr(E);
1463
1464 unsigned NumAssocs = Record.readInt();
1465 assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
1466 E->IsExprPredicate = Record.readInt();
1467 E->ResultIndex = Record.readInt();
1468 E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
1469 E->DefaultLoc = readSourceLocation();
1470 E->RParenLoc = readSourceLocation();
1471
1472 // During serialization, either one more Stmt or one more
1473 // TypeSourceInfo was encoded to account for the predicate
1474 // (whether it was an expression or a type).
1475 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1476 for (unsigned I = 0, N = NumAssocs + (E->IsExprPredicate ? 1 : 0); I < N; ++I)
1477 Stmts[I] = Record.readSubExpr();
1478
1479 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1480 for (unsigned I = 0, N = NumAssocs + (!E->IsExprPredicate ? 1 : 0); I < N;
1481 ++I)
1482 TSIs[I] = readTypeSourceInfo();
1483}
1484
1485void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1486 VisitExpr(E);
1487 unsigned numSemanticExprs = Record.readInt();
1488 assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
1489 E->PseudoObjectExprBits.ResultIndex = Record.readInt();
1490
1491 // Read the syntactic expression.
1492 E->getTrailingObjects()[0] = Record.readSubExpr();
1493
1494 // Read all the semantic expressions.
1495 for (unsigned i = 0; i != numSemanticExprs; ++i) {
1496 Expr *subExpr = Record.readSubExpr();
1497 E->getTrailingObjects()[i + 1] = subExpr;
1498 }
1499}
1500
1501void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
1502 VisitExpr(E);
1503 E->Op = AtomicExpr::AtomicOp(Record.readInt());
1504 E->NumSubExprs = AtomicExpr::getNumSubExprs(Op: E->Op);
1505 for (unsigned I = 0; I != E->NumSubExprs; ++I)
1506 E->SubExprs[I] = Record.readSubExpr();
1507 E->BuiltinLoc = readSourceLocation();
1508 E->RParenLoc = readSourceLocation();
1509}
1510
1511//===----------------------------------------------------------------------===//
1512// Objective-C Expressions and Statements
1513
1514void ASTStmtReader::VisitObjCObjectLiteral(ObjCObjectLiteral *E) {
1515 VisitExpr(E);
1516 E->setExpressibleAsConstantInitializer(Record.readInt());
1517}
1518
1519void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1520 VisitObjCObjectLiteral(E);
1521 E->setString(cast<StringLiteral>(Val: Record.readSubStmt()));
1522 E->setAtLoc(readSourceLocation());
1523}
1524
1525void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1526 VisitObjCObjectLiteral(E);
1527 // could be one of several IntegerLiteral, FloatLiteral, etc.
1528 E->SubExpr = Record.readSubStmt();
1529 E->BoxingMethod = readDeclAs<ObjCMethodDecl>();
1530 E->Range = readSourceRange();
1531}
1532
1533void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1534 VisitObjCObjectLiteral(E);
1535 unsigned NumElements = Record.readInt();
1536 assert(NumElements == E->getNumElements() && "Wrong number of elements");
1537 Expr **Elements = E->getElements();
1538 for (unsigned I = 0, N = NumElements; I != N; ++I)
1539 Elements[I] = Record.readSubExpr();
1540 E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1541 E->Range = readSourceRange();
1542}
1543
1544void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1545 VisitObjCObjectLiteral(E);
1546 unsigned NumElements = Record.readInt();
1547 assert(NumElements == E->getNumElements() && "Wrong number of elements");
1548 bool HasPackExpansions = Record.readInt();
1549 assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
1550 auto *KeyValues =
1551 E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
1552 auto *Expansions =
1553 E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
1554 for (unsigned I = 0; I != NumElements; ++I) {
1555 KeyValues[I].Key = Record.readSubExpr();
1556 KeyValues[I].Value = Record.readSubExpr();
1557 if (HasPackExpansions) {
1558 Expansions[I].EllipsisLoc = readSourceLocation();
1559 Expansions[I].NumExpansionsPlusOne = Record.readInt();
1560 }
1561 }
1562 E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1563 E->Range = readSourceRange();
1564}
1565
1566void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1567 VisitExpr(E);
1568 E->setEncodedTypeSourceInfo(readTypeSourceInfo());
1569 E->setAtLoc(readSourceLocation());
1570 E->setRParenLoc(readSourceLocation());
1571}
1572
1573void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1574 VisitExpr(E);
1575 E->setSelector(Record.readSelector());
1576 E->setAtLoc(readSourceLocation());
1577 E->setRParenLoc(readSourceLocation());
1578}
1579
1580void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1581 VisitExpr(E);
1582 E->setProtocol(readDeclAs<ObjCProtocolDecl>());
1583 E->setAtLoc(readSourceLocation());
1584 E->ProtoLoc = readSourceLocation();
1585 E->setRParenLoc(readSourceLocation());
1586}
1587
1588void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1589 VisitExpr(E);
1590 E->setDecl(readDeclAs<ObjCIvarDecl>());
1591 E->setLocation(readSourceLocation());
1592 E->setOpLoc(readSourceLocation());
1593 E->setBase(Record.readSubExpr());
1594 E->setIsArrow(Record.readInt());
1595 E->setIsFreeIvar(Record.readInt());
1596}
1597
1598void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1599 VisitExpr(E);
1600 unsigned MethodRefFlags = Record.readInt();
1601 bool Implicit = Record.readInt() != 0;
1602 if (Implicit) {
1603 auto *Getter = readDeclAs<ObjCMethodDecl>();
1604 auto *Setter = readDeclAs<ObjCMethodDecl>();
1605 E->setImplicitProperty(Getter, Setter, methRefFlags: MethodRefFlags);
1606 } else {
1607 E->setExplicitProperty(D: readDeclAs<ObjCPropertyDecl>(), methRefFlags: MethodRefFlags);
1608 }
1609 E->setLocation(readSourceLocation());
1610 E->setReceiverLocation(readSourceLocation());
1611 switch (Record.readInt()) {
1612 case 0:
1613 E->setBase(Record.readSubExpr());
1614 break;
1615 case 1:
1616 E->setSuperReceiver(Record.readType());
1617 break;
1618 case 2:
1619 E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>());
1620 break;
1621 }
1622}
1623
1624void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1625 VisitExpr(E);
1626 E->setRBracket(readSourceLocation());
1627 E->setBaseExpr(Record.readSubExpr());
1628 E->setKeyExpr(Record.readSubExpr());
1629 E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1630 E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1631}
1632
1633void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1634 VisitExpr(E);
1635 assert(Record.peekInt() == E->getNumArgs());
1636 Record.skipInts(N: 1);
1637 unsigned NumStoredSelLocs = Record.readInt();
1638 E->SelLocsKind = Record.readInt();
1639 E->setDelegateInitCall(Record.readInt());
1640 E->IsImplicit = Record.readInt();
1641 auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
1642 switch (Kind) {
1643 case ObjCMessageExpr::Instance:
1644 E->setInstanceReceiver(Record.readSubExpr());
1645 break;
1646
1647 case ObjCMessageExpr::Class:
1648 E->setClassReceiver(readTypeSourceInfo());
1649 break;
1650
1651 case ObjCMessageExpr::SuperClass:
1652 case ObjCMessageExpr::SuperInstance: {
1653 QualType T = Record.readType();
1654 SourceLocation SuperLoc = readSourceLocation();
1655 E->setSuper(Loc: SuperLoc, T, IsInstanceSuper: Kind == ObjCMessageExpr::SuperInstance);
1656 break;
1657 }
1658 }
1659
1660 assert(Kind == E->getReceiverKind());
1661
1662 if (Record.readInt())
1663 E->setMethodDecl(readDeclAs<ObjCMethodDecl>());
1664 else
1665 E->setSelector(Record.readSelector());
1666
1667 E->LBracLoc = readSourceLocation();
1668 E->RBracLoc = readSourceLocation();
1669
1670 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1671 E->setArg(Arg: I, ArgExpr: Record.readSubExpr());
1672
1673 SourceLocation *Locs = E->getStoredSelLocs();
1674 for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1675 Locs[I] = readSourceLocation();
1676}
1677
1678void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1679 VisitStmt(S);
1680 S->setElement(Record.readSubStmt());
1681 S->setCollection(Record.readSubExpr());
1682 S->setBody(Record.readSubStmt());
1683 S->setForLoc(readSourceLocation());
1684 S->setRParenLoc(readSourceLocation());
1685}
1686
1687void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1688 VisitStmt(S);
1689 S->setCatchBody(Record.readSubStmt());
1690 S->setCatchParamDecl(readDeclAs<VarDecl>());
1691 S->setAtCatchLoc(readSourceLocation());
1692 S->setRParenLoc(readSourceLocation());
1693}
1694
1695void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1696 VisitStmt(S);
1697 S->setFinallyBody(Record.readSubStmt());
1698 S->setAtFinallyLoc(readSourceLocation());
1699}
1700
1701void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1702 VisitStmt(S); // FIXME: no test coverage.
1703 S->setSubStmt(Record.readSubStmt());
1704 S->setAtLoc(readSourceLocation());
1705}
1706
1707void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1708 VisitStmt(S);
1709 assert(Record.peekInt() == S->getNumCatchStmts());
1710 Record.skipInts(N: 1);
1711 bool HasFinally = Record.readInt();
1712 S->setTryBody(Record.readSubStmt());
1713 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1714 S->setCatchStmt(I, S: cast_or_null<ObjCAtCatchStmt>(Val: Record.readSubStmt()));
1715
1716 if (HasFinally)
1717 S->setFinallyStmt(Record.readSubStmt());
1718 S->setAtTryLoc(readSourceLocation());
1719}
1720
1721void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1722 VisitStmt(S); // FIXME: no test coverage.
1723 S->setSynchExpr(Record.readSubStmt());
1724 S->setSynchBody(Record.readSubStmt());
1725 S->setAtSynchronizedLoc(readSourceLocation());
1726}
1727
1728void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1729 VisitStmt(S); // FIXME: no test coverage.
1730 S->setThrowExpr(Record.readSubStmt());
1731 S->setThrowLoc(readSourceLocation());
1732}
1733
1734void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1735 VisitExpr(E);
1736 E->setValue(Record.readInt());
1737 E->setLocation(readSourceLocation());
1738}
1739
1740void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1741 VisitExpr(E);
1742 SourceRange R = Record.readSourceRange();
1743 E->AtLoc = R.getBegin();
1744 E->RParen = R.getEnd();
1745 E->VersionToCheck = Record.readVersionTuple();
1746}
1747
1748//===----------------------------------------------------------------------===//
1749// C++ Expressions and Statements
1750//===----------------------------------------------------------------------===//
1751
1752void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1753 VisitStmt(S);
1754 S->CatchLoc = readSourceLocation();
1755 S->ExceptionDecl = readDeclAs<VarDecl>();
1756 S->HandlerBlock = Record.readSubStmt();
1757}
1758
1759void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1760 VisitStmt(S);
1761 assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
1762 Record.skipInts(N: 1);
1763 S->TryLoc = readSourceLocation();
1764 S->getStmts()[0] = Record.readSubStmt();
1765 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1766 S->getStmts()[i + 1] = Record.readSubStmt();
1767}
1768
1769void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1770 VisitStmt(S);
1771 S->ForLoc = readSourceLocation();
1772 S->CoawaitLoc = readSourceLocation();
1773 S->ColonLoc = readSourceLocation();
1774 S->RParenLoc = readSourceLocation();
1775 S->setInit(Record.readSubStmt());
1776 S->setRangeStmt(Record.readSubStmt());
1777 S->setBeginStmt(Record.readSubStmt());
1778 S->setEndStmt(Record.readSubStmt());
1779 S->setCond(Record.readSubExpr());
1780 S->setInc(Record.readSubExpr());
1781 S->setLoopVarStmt(Record.readSubStmt());
1782 S->setBody(Record.readSubStmt());
1783}
1784
1785void ASTStmtReader::VisitCXXExpansionStmtPattern(CXXExpansionStmtPattern *S) {
1786 VisitStmt(S);
1787 Record.skipInts(N: 1); // Skip kind.
1788 S->LParenLoc = readSourceLocation();
1789 S->ColonLoc = readSourceLocation();
1790 S->RParenLoc = readSourceLocation();
1791 S->ParentDecl = cast<CXXExpansionStmtDecl>(Val: Record.readDeclRef());
1792 for (Stmt *&SubStmt : S->children())
1793 SubStmt = Record.readSubStmt();
1794}
1795
1796void ASTStmtReader::VisitCXXExpansionStmtInstantiation(
1797 CXXExpansionStmtInstantiation *S) {
1798 VisitStmt(S);
1799 Record.skipInts(N: 2);
1800 S->Parent = cast<CXXExpansionStmtDecl>(Val: Record.readDeclRef());
1801 for (unsigned I = 0; I < S->getNumSubStmts(); ++I)
1802 S->getAllSubStmts()[I] = Record.readSubStmt();
1803 S->setShouldApplyLifetimeExtensionToPreamble(Record.readBool());
1804}
1805
1806void ASTStmtReader::VisitCXXExpansionSelectExpr(CXXExpansionSelectExpr *E) {
1807 VisitExpr(E);
1808 E->setRangeExpr(cast<InitListExpr>(Val: Record.readSubExpr()));
1809 E->setIndexExpr(Record.readSubExpr());
1810}
1811
1812void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1813 VisitStmt(S);
1814 S->KeywordLoc = readSourceLocation();
1815 S->IsIfExists = Record.readInt();
1816 S->QualifierLoc = Record.readNestedNameSpecifierLoc();
1817 S->NameInfo = Record.readDeclarationNameInfo();
1818 S->SubStmt = Record.readSubStmt();
1819}
1820
1821void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1822 VisitCallExpr(E);
1823 E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
1824 E->CXXOperatorCallExprBits.IsReversed = Record.readInt();
1825 E->BeginLoc = Record.readSourceLocation();
1826}
1827
1828void ASTStmtReader::VisitCXXRewrittenBinaryOperator(
1829 CXXRewrittenBinaryOperator *E) {
1830 VisitExpr(E);
1831 E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt();
1832 E->SemanticForm = Record.readSubExpr();
1833}
1834
1835void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1836 VisitExpr(E);
1837
1838 unsigned NumArgs = Record.readInt();
1839 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1840
1841 E->CXXConstructExprBits.Elidable = Record.readInt();
1842 E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
1843 E->CXXConstructExprBits.ListInitialization = Record.readInt();
1844 E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
1845 E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
1846 E->CXXConstructExprBits.ConstructionKind = Record.readInt();
1847 E->CXXConstructExprBits.IsImmediateEscalating = Record.readInt();
1848 E->CXXConstructExprBits.Loc = readSourceLocation();
1849 E->Constructor = readDeclAs<CXXConstructorDecl>();
1850 E->ParenOrBraceRange = readSourceRange();
1851
1852 for (unsigned I = 0; I != NumArgs; ++I)
1853 E->setArg(Arg: I, ArgExpr: Record.readSubExpr());
1854}
1855
1856void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1857 VisitExpr(E);
1858 E->Constructor = readDeclAs<CXXConstructorDecl>();
1859 E->Loc = readSourceLocation();
1860 E->ConstructsVirtualBase = Record.readInt();
1861 E->InheritedFromVirtualBase = Record.readInt();
1862}
1863
1864void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1865 VisitCXXConstructExpr(E);
1866 E->TSI = readTypeSourceInfo();
1867}
1868
1869void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1870 VisitExpr(E);
1871 unsigned NumCaptures = Record.readInt();
1872 (void)NumCaptures;
1873 assert(NumCaptures == E->LambdaExprBits.NumCaptures);
1874 E->IntroducerRange = readSourceRange();
1875 E->LambdaExprBits.CaptureDefault = Record.readInt();
1876 E->CaptureDefaultLoc = readSourceLocation();
1877 E->LambdaExprBits.ExplicitParams = Record.readInt();
1878 E->LambdaExprBits.ExplicitResultType = Record.readInt();
1879 E->ClosingBrace = readSourceLocation();
1880
1881 // Read capture initializers.
1882 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1883 CEnd = E->capture_init_end();
1884 C != CEnd; ++C)
1885 *C = Record.readSubExpr();
1886
1887 // The body will be lazily deserialized when needed from the call operator
1888 // declaration.
1889}
1890
1891void
1892ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1893 VisitExpr(E);
1894 E->SubExpr = Record.readSubExpr();
1895}
1896
1897void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1898 VisitExplicitCastExpr(E);
1899 SourceRange R = readSourceRange();
1900 E->Loc = R.getBegin();
1901 E->RParenLoc = R.getEnd();
1902 if (CurrentUnpackingBits->getNextBit())
1903 E->AngleBrackets = readSourceRange();
1904}
1905
1906void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1907 return VisitCXXNamedCastExpr(E);
1908}
1909
1910void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1911 return VisitCXXNamedCastExpr(E);
1912}
1913
1914void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1915 return VisitCXXNamedCastExpr(E);
1916}
1917
1918void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1919 return VisitCXXNamedCastExpr(E);
1920}
1921
1922void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1923 return VisitCXXNamedCastExpr(E);
1924}
1925
1926void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1927 VisitExplicitCastExpr(E);
1928 E->setLParenLoc(readSourceLocation());
1929 E->setRParenLoc(readSourceLocation());
1930}
1931
1932void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1933 VisitExplicitCastExpr(E);
1934 E->KWLoc = readSourceLocation();
1935 E->RParenLoc = readSourceLocation();
1936}
1937
1938void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1939 VisitCallExpr(E);
1940 E->UDSuffixLoc = readSourceLocation();
1941}
1942
1943void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1944 VisitExpr(E);
1945 E->setValue(Record.readInt());
1946 E->setLocation(readSourceLocation());
1947}
1948
1949void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1950 VisitExpr(E);
1951 E->setLocation(readSourceLocation());
1952}
1953
1954void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1955 VisitExpr(E);
1956 E->setSourceRange(readSourceRange());
1957 if (E->isTypeOperand())
1958 E->Operand = readTypeSourceInfo();
1959 else
1960 E->Operand = Record.readSubExpr();
1961}
1962
1963void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1964 VisitExpr(E);
1965 E->setLocation(readSourceLocation());
1966 E->setImplicit(Record.readInt());
1967 E->setCapturedByCopyInLambdaWithExplicitObjectParameter(Record.readInt());
1968}
1969
1970void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1971 VisitExpr(E);
1972 E->CXXThrowExprBits.ThrowLoc = readSourceLocation();
1973 E->Operand = Record.readSubExpr();
1974 E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
1975}
1976
1977void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1978 VisitExpr(E);
1979 E->Param = readDeclAs<ParmVarDecl>();
1980 E->UsedContext = readDeclAs<DeclContext>();
1981 E->CXXDefaultArgExprBits.Loc = readSourceLocation();
1982 E->CXXDefaultArgExprBits.HasRewrittenInit = Record.readInt();
1983 if (E->CXXDefaultArgExprBits.HasRewrittenInit)
1984 *E->getTrailingObjects() = Record.readSubExpr();
1985}
1986
1987void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1988 VisitExpr(E);
1989 E->CXXDefaultInitExprBits.HasRewrittenInit = Record.readInt();
1990 E->Field = readDeclAs<FieldDecl>();
1991 E->UsedContext = readDeclAs<DeclContext>();
1992 E->CXXDefaultInitExprBits.Loc = readSourceLocation();
1993 if (E->CXXDefaultInitExprBits.HasRewrittenInit)
1994 *E->getTrailingObjects() = Record.readSubExpr();
1995}
1996
1997void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1998 VisitExpr(E);
1999 E->setTemporary(Record.readCXXTemporary());
2000 E->setSubExpr(Record.readSubExpr());
2001}
2002
2003void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
2004 VisitExpr(E);
2005 E->TypeInfo = readTypeSourceInfo();
2006 E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
2007}
2008
2009void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
2010 VisitExpr(E);
2011
2012 bool IsArray = Record.readInt();
2013 bool HasInit = Record.readInt();
2014 unsigned NumPlacementArgs = Record.readInt();
2015 bool IsParenTypeId = Record.readInt();
2016
2017 E->CXXNewExprBits.IsGlobalNew = Record.readInt();
2018 E->CXXNewExprBits.ShouldPassAlignment = Record.readInt();
2019 E->CXXNewExprBits.ShouldPassTypeIdentity = Record.readInt();
2020 E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt();
2021 E->CXXNewExprBits.HasInitializer = Record.readInt();
2022 E->CXXNewExprBits.StoredInitializationStyle = Record.readInt();
2023
2024 assert((IsArray == E->isArray()) && "Wrong IsArray!");
2025 assert((HasInit == E->hasInitializer()) && "Wrong HasInit!");
2026 assert((NumPlacementArgs == E->getNumPlacementArgs()) &&
2027 "Wrong NumPlacementArgs!");
2028 assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!");
2029 (void)IsArray;
2030 (void)HasInit;
2031 (void)NumPlacementArgs;
2032
2033 E->setOperatorNew(readDeclAs<FunctionDecl>());
2034 E->setOperatorDelete(readDeclAs<FunctionDecl>());
2035 E->AllocatedTypeInfo = readTypeSourceInfo();
2036 if (IsParenTypeId)
2037 E->getTrailingObjects<SourceRange>()[0] = readSourceRange();
2038 E->Range = readSourceRange();
2039 E->DirectInitRange = readSourceRange();
2040
2041 // Install all the subexpressions.
2042 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),
2043 N = E->raw_arg_end();
2044 I != N; ++I)
2045 *I = Record.readSubStmt();
2046}
2047
2048void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
2049 VisitExpr(E);
2050 E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
2051 E->CXXDeleteExprBits.ArrayForm = Record.readInt();
2052 E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
2053 E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
2054 E->OperatorDelete = readDeclAs<FunctionDecl>();
2055 E->Argument = Record.readSubExpr();
2056 E->CXXDeleteExprBits.Loc = readSourceLocation();
2057}
2058
2059void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
2060 VisitExpr(E);
2061
2062 E->Base = Record.readSubExpr();
2063 E->IsArrow = Record.readInt();
2064 E->OperatorLoc = readSourceLocation();
2065 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2066 E->ScopeType = readTypeSourceInfo();
2067 E->ColonColonLoc = readSourceLocation();
2068 E->TildeLoc = readSourceLocation();
2069
2070 IdentifierInfo *II = Record.readIdentifier();
2071 if (II)
2072 E->setDestroyedType(II, Loc: readSourceLocation());
2073 else
2074 E->setDestroyedType(readTypeSourceInfo());
2075}
2076
2077void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
2078 VisitExpr(E);
2079
2080 unsigned NumObjects = Record.readInt();
2081 assert(NumObjects == E->getNumObjects());
2082 for (unsigned i = 0; i != NumObjects; ++i) {
2083 unsigned CleanupKind = Record.readInt();
2084 ExprWithCleanups::CleanupObject Obj;
2085 if (CleanupKind == COK_Block)
2086 Obj = readDeclAs<BlockDecl>();
2087 else if (CleanupKind == COK_CompoundLiteral)
2088 Obj = cast<CompoundLiteralExpr>(Val: Record.readSubExpr());
2089 else
2090 llvm_unreachable("unexpected cleanup object type");
2091 E->getTrailingObjects()[i] = Obj;
2092 }
2093
2094 E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
2095 E->SubExpr = Record.readSubExpr();
2096}
2097
2098void ASTStmtReader::VisitCXXDependentScopeMemberExpr(
2099 CXXDependentScopeMemberExpr *E) {
2100 VisitExpr(E);
2101
2102 unsigned NumTemplateArgs = Record.readInt();
2103 CurrentUnpackingBits.emplace(args: Record.readInt());
2104 bool HasTemplateKWAndArgsInfo = CurrentUnpackingBits->getNextBit();
2105 bool HasFirstQualifierFoundInScope = CurrentUnpackingBits->getNextBit();
2106
2107 assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) &&
2108 "Wrong HasTemplateKWAndArgsInfo!");
2109 assert(
2110 (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) &&
2111 "Wrong HasFirstQualifierFoundInScope!");
2112
2113 if (HasTemplateKWAndArgsInfo)
2114 ReadTemplateKWAndArgsInfo(
2115 Args&: *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
2116 ArgsLocArray: E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
2117
2118 assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
2119 "Wrong NumTemplateArgs!");
2120
2121 E->CXXDependentScopeMemberExprBits.IsArrow =
2122 CurrentUnpackingBits->getNextBit();
2123
2124 E->BaseType = Record.readType();
2125 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2126 // not ImplicitAccess
2127 if (CurrentUnpackingBits->getNextBit())
2128 E->Base = Record.readSubExpr();
2129 else
2130 E->Base = nullptr;
2131
2132 E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation();
2133
2134 if (HasFirstQualifierFoundInScope)
2135 *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
2136
2137 E->MemberNameInfo = Record.readDeclarationNameInfo();
2138}
2139
2140void
2141ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
2142 VisitExpr(E);
2143
2144 if (CurrentUnpackingBits->getNextBit()) // HasTemplateKWAndArgsInfo
2145 ReadTemplateKWAndArgsInfo(
2146 Args&: *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
2147 ArgsLocArray: E->getTrailingObjects<TemplateArgumentLoc>(),
2148 /*NumTemplateArgs=*/CurrentUnpackingBits->getNextBits(/*Width=*/16));
2149
2150 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2151 E->NameInfo = Record.readDeclarationNameInfo();
2152}
2153
2154void
2155ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
2156 VisitExpr(E);
2157 assert(Record.peekInt() == E->getNumArgs() &&
2158 "Read wrong record during creation ?");
2159 Record.skipInts(N: 1);
2160 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2161 E->setArg(I, E: Record.readSubExpr());
2162 E->TypeAndInitForm.setPointer(readTypeSourceInfo());
2163 E->setLParenLoc(readSourceLocation());
2164 E->setRParenLoc(readSourceLocation());
2165 E->TypeAndInitForm.setInt(Record.readInt());
2166}
2167
2168void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
2169 VisitExpr(E);
2170
2171 unsigned NumResults = Record.readInt();
2172 CurrentUnpackingBits.emplace(args: Record.readInt());
2173 bool HasTemplateKWAndArgsInfo = CurrentUnpackingBits->getNextBit();
2174 assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");
2175 assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
2176 "Wrong HasTemplateKWAndArgsInfo!");
2177
2178 unsigned NumTemplateArgs = 0;
2179 if (HasTemplateKWAndArgsInfo) {
2180 NumTemplateArgs = Record.readInt();
2181 ReadTemplateKWAndArgsInfo(Args&: *E->getTrailingASTTemplateKWAndArgsInfo(),
2182 ArgsLocArray: E->getTrailingTemplateArgumentLoc(),
2183 NumTemplateArgs);
2184 }
2185
2186 UnresolvedSet<8> Decls;
2187 for (unsigned I = 0; I != NumResults; ++I) {
2188 auto *D = readDeclAs<NamedDecl>();
2189 auto AS = (AccessSpecifier)Record.readInt();
2190 Decls.addDecl(D, AS);
2191 }
2192
2193 DeclAccessPair *Results = E->getTrailingResults();
2194 UnresolvedSetIterator Iter = Decls.begin();
2195 for (unsigned I = 0; I != NumResults; ++I) {
2196 Results[I] = (Iter + I).getPair();
2197 }
2198
2199 assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
2200 "Wrong NumTemplateArgs!");
2201
2202 E->NameInfo = Record.readDeclarationNameInfo();
2203 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2204}
2205
2206void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2207 VisitOverloadExpr(E);
2208 E->UnresolvedMemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit();
2209 E->UnresolvedMemberExprBits.HasUnresolvedUsing =
2210 CurrentUnpackingBits->getNextBit();
2211
2212 if (/*!isImplicitAccess=*/CurrentUnpackingBits->getNextBit())
2213 E->Base = Record.readSubExpr();
2214 else
2215 E->Base = nullptr;
2216
2217 E->OperatorLoc = readSourceLocation();
2218
2219 E->BaseType = Record.readType();
2220}
2221
2222void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2223 VisitOverloadExpr(E);
2224 E->UnresolvedLookupExprBits.RequiresADL = CurrentUnpackingBits->getNextBit();
2225 E->NamingClass = readDeclAs<CXXRecordDecl>();
2226}
2227
2228void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
2229 VisitExpr(E);
2230 E->TypeTraitExprBits.IsBooleanTypeTrait = Record.readInt();
2231 E->TypeTraitExprBits.NumArgs = Record.readInt();
2232 E->TypeTraitExprBits.Kind = Record.readInt();
2233
2234 if (E->TypeTraitExprBits.IsBooleanTypeTrait)
2235 E->TypeTraitExprBits.Value = Record.readInt();
2236 else
2237 *E->getTrailingObjects<APValue>() = Record.readAPValue();
2238
2239 SourceRange Range = readSourceRange();
2240 E->Loc = Range.getBegin();
2241 E->RParenLoc = Range.getEnd();
2242
2243 auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
2244 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2245 Args[I] = readTypeSourceInfo();
2246}
2247
2248void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2249 VisitExpr(E);
2250 E->ArrayTypeTraitExprBits.ATT = (ArrayTypeTrait)Record.readInt();
2251 E->Value = (unsigned int)Record.readInt();
2252 SourceRange Range = readSourceRange();
2253 E->Loc = Range.getBegin();
2254 E->RParen = Range.getEnd();
2255 E->QueriedType = readTypeSourceInfo();
2256 E->Dimension = Record.readSubExpr();
2257}
2258
2259void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2260 VisitExpr(E);
2261 E->ExpressionTraitExprBits.ET = (ExpressionTrait)Record.readInt();
2262 E->ExpressionTraitExprBits.Value = (bool)Record.readInt();
2263 SourceRange Range = readSourceRange();
2264 E->QueriedExpression = Record.readSubExpr();
2265 E->Loc = Range.getBegin();
2266 E->RParen = Range.getEnd();
2267}
2268
2269void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2270 VisitExpr(E);
2271 E->CXXNoexceptExprBits.Value = Record.readInt();
2272 E->Range = readSourceRange();
2273 E->Operand = Record.readSubExpr();
2274}
2275
2276void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
2277 VisitExpr(E);
2278 E->EllipsisLoc = readSourceLocation();
2279 E->NumExpansions = Record.readInt();
2280 E->Pattern = Record.readSubExpr();
2281}
2282
2283void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2284 VisitExpr(E);
2285 unsigned NumPartialArgs = Record.readInt();
2286 E->OperatorLoc = readSourceLocation();
2287 E->PackLoc = readSourceLocation();
2288 E->RParenLoc = readSourceLocation();
2289 E->Pack = Record.readDeclAs<NamedDecl>();
2290 if (E->isPartiallySubstituted()) {
2291 assert(E->Length == NumPartialArgs);
2292 for (auto *I = E->getTrailingObjects(), *E = I + NumPartialArgs; I != E;
2293 ++I)
2294 new (I) TemplateArgument(Record.readTemplateArgument());
2295 } else if (!E->isValueDependent()) {
2296 E->Length = Record.readInt();
2297 }
2298}
2299
2300void ASTStmtReader::VisitPackIndexingExpr(PackIndexingExpr *E) {
2301 VisitExpr(E);
2302 E->PackIndexingExprBits.TransformedExpressions = Record.readInt();
2303 E->PackIndexingExprBits.FullySubstituted = Record.readInt();
2304 E->EllipsisLoc = readSourceLocation();
2305 E->RSquareLoc = readSourceLocation();
2306 E->SubExprs[0] = Record.readStmt();
2307 E->SubExprs[1] = Record.readStmt();
2308 auto **Exprs = E->getTrailingObjects();
2309 for (unsigned I = 0; I < E->PackIndexingExprBits.TransformedExpressions; ++I)
2310 Exprs[I] = Record.readExpr();
2311}
2312
2313void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
2314 SubstNonTypeTemplateParmExpr *E) {
2315 VisitExpr(E);
2316 E->AssociatedDeclAndFinal.setPointer(readDeclAs<Decl>());
2317 E->AssociatedDeclAndFinal.setInt(CurrentUnpackingBits->getNextBit());
2318 E->Index = CurrentUnpackingBits->getNextBits(/*Width=*/12);
2319 E->PackIndex = Record.readUnsignedOrNone().toInternalRepresentation();
2320 E->ParamType = Record.readType();
2321 E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
2322 E->Replacement = Record.readSubExpr();
2323}
2324
2325void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
2326 SubstNonTypeTemplateParmPackExpr *E) {
2327 VisitExpr(E);
2328 E->AssociatedDecl = readDeclAs<Decl>();
2329 E->Final = CurrentUnpackingBits->getNextBit();
2330 E->Index = Record.readInt();
2331 TemplateArgument ArgPack = Record.readTemplateArgument();
2332 if (ArgPack.getKind() != TemplateArgument::Pack)
2333 return;
2334
2335 E->Arguments = ArgPack.pack_begin();
2336 E->NumArguments = ArgPack.pack_size();
2337 E->NameLoc = readSourceLocation();
2338}
2339
2340void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2341 VisitExpr(E);
2342 E->NumParameters = Record.readInt();
2343 E->ParamPack = readDeclAs<ValueDecl>();
2344 E->NameLoc = readSourceLocation();
2345 auto **Parms = E->getTrailingObjects();
2346 for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
2347 Parms[i] = readDeclAs<ValueDecl>();
2348}
2349
2350void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2351 VisitExpr(E);
2352 bool HasMaterialzedDecl = Record.readInt();
2353 if (HasMaterialzedDecl)
2354 E->State = cast<LifetimeExtendedTemporaryDecl>(Val: Record.readDecl());
2355 else
2356 E->State = Record.readSubExpr();
2357}
2358
2359void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
2360 VisitExpr(E);
2361 E->LParenLoc = readSourceLocation();
2362 E->EllipsisLoc = readSourceLocation();
2363 E->RParenLoc = readSourceLocation();
2364 E->NumExpansions = Record.readUnsignedOrNone();
2365 E->SubExprs[0] = Record.readSubExpr();
2366 E->SubExprs[1] = Record.readSubExpr();
2367 E->SubExprs[2] = Record.readSubExpr();
2368 E->CXXFoldExprBits.Opcode = (BinaryOperatorKind)Record.readInt();
2369}
2370
2371void ASTStmtReader::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
2372 VisitExpr(E);
2373 unsigned ExpectedNumExprs = Record.readInt();
2374 assert(E->NumExprs == ExpectedNumExprs &&
2375 "expected number of expressions does not equal the actual number of "
2376 "serialized expressions.");
2377 E->NumUserSpecifiedExprs = Record.readInt();
2378 E->InitLoc = readSourceLocation();
2379 E->LParenLoc = readSourceLocation();
2380 E->RParenLoc = readSourceLocation();
2381 for (unsigned I = 0; I < ExpectedNumExprs; I++)
2382 E->getTrailingObjects()[I] = Record.readSubExpr();
2383
2384 bool HasArrayFillerOrUnionDecl = Record.readBool();
2385 if (HasArrayFillerOrUnionDecl) {
2386 bool HasArrayFiller = Record.readBool();
2387 if (HasArrayFiller) {
2388 E->setArrayFiller(Record.readSubExpr());
2389 } else {
2390 E->setInitializedFieldInUnion(readDeclAs<FieldDecl>());
2391 }
2392 }
2393 E->updateDependence();
2394}
2395
2396void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2397 VisitExpr(E);
2398 E->SourceExpr = Record.readSubExpr();
2399 E->OpaqueValueExprBits.Loc = readSourceLocation();
2400 E->setIsUnique(Record.readInt());
2401}
2402
2403void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
2404 VisitExpr(E);
2405 unsigned NumArgs = Record.readInt();
2406 E->BeginLoc = readSourceLocation();
2407 E->EndLoc = readSourceLocation();
2408 assert((NumArgs + 0LL ==
2409 std::distance(E->children().begin(), E->children().end())) &&
2410 "Wrong NumArgs!");
2411 (void)NumArgs;
2412 for (Stmt *&Child : E->children())
2413 Child = Record.readSubStmt();
2414}
2415
2416//===----------------------------------------------------------------------===//
2417// Microsoft Expressions and Statements
2418//===----------------------------------------------------------------------===//
2419void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2420 VisitExpr(E);
2421 E->IsArrow = (Record.readInt() != 0);
2422 E->BaseExpr = Record.readSubExpr();
2423 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2424 E->MemberLoc = readSourceLocation();
2425 E->TheDecl = readDeclAs<MSPropertyDecl>();
2426}
2427
2428void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2429 VisitExpr(E);
2430 E->setBase(Record.readSubExpr());
2431 E->setIdx(Record.readSubExpr());
2432 E->setRBracketLoc(readSourceLocation());
2433}
2434
2435void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2436 VisitExpr(E);
2437 E->setSourceRange(readSourceRange());
2438 E->Guid = readDeclAs<MSGuidDecl>();
2439 if (E->isTypeOperand())
2440 E->Operand = readTypeSourceInfo();
2441 else
2442 E->Operand = Record.readSubExpr();
2443}
2444
2445void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
2446 VisitStmt(S);
2447 S->setLeaveLoc(readSourceLocation());
2448}
2449
2450void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
2451 VisitStmt(S);
2452 S->Loc = readSourceLocation();
2453 S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
2454 S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
2455}
2456
2457void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
2458 VisitStmt(S);
2459 S->Loc = readSourceLocation();
2460 S->Block = Record.readSubStmt();
2461}
2462
2463void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
2464 VisitStmt(S);
2465 S->IsCXXTry = Record.readInt();
2466 S->TryLoc = readSourceLocation();
2467 S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
2468 S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
2469}
2470
2471//===----------------------------------------------------------------------===//
2472// CUDA Expressions and Statements
2473//===----------------------------------------------------------------------===//
2474
2475void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2476 VisitCallExpr(E);
2477 E->setPreArg(I: CUDAKernelCallExpr::CONFIG, PreArg: Record.readSubExpr());
2478}
2479
2480//===----------------------------------------------------------------------===//
2481// OpenCL Expressions and Statements.
2482//===----------------------------------------------------------------------===//
2483void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
2484 VisitExpr(E);
2485 E->BuiltinLoc = readSourceLocation();
2486 E->RParenLoc = readSourceLocation();
2487 E->SrcExpr = Record.readSubExpr();
2488}
2489
2490//===----------------------------------------------------------------------===//
2491// OpenMP Directives.
2492//===----------------------------------------------------------------------===//
2493
2494void ASTStmtReader::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
2495 VisitStmt(S);
2496 for (Stmt *&SubStmt : S->SubStmts)
2497 SubStmt = Record.readSubStmt();
2498}
2499
2500void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2501 Record.readOMPChildren(Data: E->Data);
2502 E->setLocStart(readSourceLocation());
2503 E->setLocEnd(readSourceLocation());
2504}
2505
2506void ASTStmtReader::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
2507 VisitStmt(S: D);
2508 // Field CollapsedNum was read in ReadStmtFromStream.
2509 Record.skipInts(N: 1);
2510 VisitOMPExecutableDirective(E: D);
2511}
2512
2513void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2514 VisitOMPLoopBasedDirective(D);
2515}
2516
2517void ASTStmtReader::VisitOMPMetaDirective(OMPMetaDirective *D) {
2518 VisitStmt(S: D);
2519 // The NumClauses field was read in ReadStmtFromStream.
2520 Record.skipInts(N: 1);
2521 VisitOMPExecutableDirective(E: D);
2522}
2523
2524void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2525 VisitStmt(S: D);
2526 VisitOMPExecutableDirective(E: D);
2527 D->setHasCancel(Record.readBool());
2528}
2529
2530void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2531 VisitOMPLoopDirective(D);
2532}
2533
2534void ASTStmtReader::VisitOMPCanonicalLoopNestTransformationDirective(
2535 OMPCanonicalLoopNestTransformationDirective *D) {
2536 VisitOMPLoopBasedDirective(D);
2537 D->setNumGeneratedTopLevelLoops(Record.readUInt32());
2538}
2539
2540void ASTStmtReader::VisitOMPTileDirective(OMPTileDirective *D) {
2541 VisitOMPCanonicalLoopNestTransformationDirective(D);
2542}
2543
2544void ASTStmtReader::VisitOMPStripeDirective(OMPStripeDirective *D) {
2545 VisitOMPCanonicalLoopNestTransformationDirective(D);
2546}
2547
2548void ASTStmtReader::VisitOMPUnrollDirective(OMPUnrollDirective *D) {
2549 VisitOMPCanonicalLoopNestTransformationDirective(D);
2550}
2551
2552void ASTStmtReader::VisitOMPReverseDirective(OMPReverseDirective *D) {
2553 VisitOMPCanonicalLoopNestTransformationDirective(D);
2554}
2555
2556void ASTStmtReader::VisitOMPCanonicalLoopSequenceTransformationDirective(
2557 OMPCanonicalLoopSequenceTransformationDirective *D) {
2558 VisitStmt(S: D);
2559 VisitOMPExecutableDirective(E: D);
2560 D->setNumGeneratedTopLevelLoops(Record.readUInt32());
2561}
2562
2563void ASTStmtReader::VisitOMPInterchangeDirective(OMPInterchangeDirective *D) {
2564 VisitOMPCanonicalLoopNestTransformationDirective(D);
2565}
2566
2567void ASTStmtReader::VisitOMPSplitDirective(OMPSplitDirective *D) {
2568 VisitOMPCanonicalLoopNestTransformationDirective(D);
2569}
2570
2571void ASTStmtReader::VisitOMPFuseDirective(OMPFuseDirective *D) {
2572 VisitOMPCanonicalLoopSequenceTransformationDirective(D);
2573}
2574
2575void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2576 VisitOMPLoopDirective(D);
2577 D->setHasCancel(Record.readBool());
2578}
2579
2580void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2581 VisitOMPLoopDirective(D);
2582}
2583
2584void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2585 VisitStmt(S: D);
2586 VisitOMPExecutableDirective(E: D);
2587 D->setHasCancel(Record.readBool());
2588}
2589
2590void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2591 VisitStmt(S: D);
2592 VisitOMPExecutableDirective(E: D);
2593 D->setHasCancel(Record.readBool());
2594}
2595
2596void ASTStmtReader::VisitOMPScopeDirective(OMPScopeDirective *D) {
2597 VisitStmt(S: D);
2598 VisitOMPExecutableDirective(E: D);
2599}
2600
2601void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2602 VisitStmt(S: D);
2603 VisitOMPExecutableDirective(E: D);
2604}
2605
2606void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2607 VisitStmt(S: D);
2608 VisitOMPExecutableDirective(E: D);
2609}
2610
2611void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2612 VisitStmt(S: D);
2613 VisitOMPExecutableDirective(E: D);
2614 D->DirName = Record.readDeclarationNameInfo();
2615}
2616
2617void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2618 VisitOMPLoopDirective(D);
2619 D->setHasCancel(Record.readBool());
2620}
2621
2622void ASTStmtReader::VisitOMPParallelForSimdDirective(
2623 OMPParallelForSimdDirective *D) {
2624 VisitOMPLoopDirective(D);
2625}
2626
2627void ASTStmtReader::VisitOMPParallelMasterDirective(
2628 OMPParallelMasterDirective *D) {
2629 VisitStmt(S: D);
2630 VisitOMPExecutableDirective(E: D);
2631}
2632
2633void ASTStmtReader::VisitOMPParallelMaskedDirective(
2634 OMPParallelMaskedDirective *D) {
2635 VisitStmt(S: D);
2636 VisitOMPExecutableDirective(E: D);
2637}
2638
2639void ASTStmtReader::VisitOMPParallelSectionsDirective(
2640 OMPParallelSectionsDirective *D) {
2641 VisitStmt(S: D);
2642 VisitOMPExecutableDirective(E: D);
2643 D->setHasCancel(Record.readBool());
2644}
2645
2646void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2647 VisitStmt(S: D);
2648 VisitOMPExecutableDirective(E: D);
2649 D->setHasCancel(Record.readBool());
2650}
2651
2652void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2653 VisitStmt(S: D);
2654 VisitOMPExecutableDirective(E: D);
2655}
2656
2657void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2658 VisitStmt(S: D);
2659 VisitOMPExecutableDirective(E: D);
2660}
2661
2662void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2663 VisitStmt(S: D);
2664 // The NumClauses field was read in ReadStmtFromStream.
2665 Record.skipInts(N: 1);
2666 VisitOMPExecutableDirective(E: D);
2667}
2668
2669void ASTStmtReader::VisitOMPAssumeDirective(OMPAssumeDirective *D) {
2670 VisitStmt(S: D);
2671 VisitOMPExecutableDirective(E: D);
2672}
2673
2674void ASTStmtReader::VisitOMPErrorDirective(OMPErrorDirective *D) {
2675 VisitStmt(S: D);
2676 // The NumClauses field was read in ReadStmtFromStream.
2677 Record.skipInts(N: 1);
2678 VisitOMPExecutableDirective(E: D);
2679}
2680
2681void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2682 VisitStmt(S: D);
2683 VisitOMPExecutableDirective(E: D);
2684}
2685
2686void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2687 VisitStmt(S: D);
2688 VisitOMPExecutableDirective(E: D);
2689}
2690
2691void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2692 VisitStmt(S: D);
2693 VisitOMPExecutableDirective(E: D);
2694}
2695
2696void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) {
2697 VisitStmt(S: D);
2698 VisitOMPExecutableDirective(E: D);
2699}
2700
2701void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2702 VisitStmt(S: D);
2703 VisitOMPExecutableDirective(E: D);
2704}
2705
2706void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2707 VisitStmt(S: D);
2708 VisitOMPExecutableDirective(E: D);
2709 D->Flags.IsXLHSInRHSPart = Record.readBool() ? 1 : 0;
2710 D->Flags.IsPostfixUpdate = Record.readBool() ? 1 : 0;
2711 D->Flags.IsFailOnly = Record.readBool() ? 1 : 0;
2712}
2713
2714void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2715 VisitStmt(S: D);
2716 VisitOMPExecutableDirective(E: D);
2717}
2718
2719void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2720 VisitStmt(S: D);
2721 VisitOMPExecutableDirective(E: D);
2722}
2723
2724void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2725 OMPTargetEnterDataDirective *D) {
2726 VisitStmt(S: D);
2727 VisitOMPExecutableDirective(E: D);
2728}
2729
2730void ASTStmtReader::VisitOMPTargetExitDataDirective(
2731 OMPTargetExitDataDirective *D) {
2732 VisitStmt(S: D);
2733 VisitOMPExecutableDirective(E: D);
2734}
2735
2736void ASTStmtReader::VisitOMPTargetParallelDirective(
2737 OMPTargetParallelDirective *D) {
2738 VisitStmt(S: D);
2739 VisitOMPExecutableDirective(E: D);
2740 D->setHasCancel(Record.readBool());
2741}
2742
2743void ASTStmtReader::VisitOMPTargetParallelForDirective(
2744 OMPTargetParallelForDirective *D) {
2745 VisitOMPLoopDirective(D);
2746 D->setHasCancel(Record.readBool());
2747}
2748
2749void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2750 VisitStmt(S: D);
2751 VisitOMPExecutableDirective(E: D);
2752}
2753
2754void ASTStmtReader::VisitOMPCancellationPointDirective(
2755 OMPCancellationPointDirective *D) {
2756 VisitStmt(S: D);
2757 VisitOMPExecutableDirective(E: D);
2758 D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2759}
2760
2761void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2762 VisitStmt(S: D);
2763 VisitOMPExecutableDirective(E: D);
2764 D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2765}
2766
2767void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2768 VisitOMPLoopDirective(D);
2769 D->setHasCancel(Record.readBool());
2770}
2771
2772void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2773 VisitOMPLoopDirective(D);
2774}
2775
2776void ASTStmtReader::VisitOMPMasterTaskLoopDirective(
2777 OMPMasterTaskLoopDirective *D) {
2778 VisitOMPLoopDirective(D);
2779 D->setHasCancel(Record.readBool());
2780}
2781
2782void ASTStmtReader::VisitOMPMaskedTaskLoopDirective(
2783 OMPMaskedTaskLoopDirective *D) {
2784 VisitOMPLoopDirective(D);
2785 D->setHasCancel(Record.readBool());
2786}
2787
2788void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective(
2789 OMPMasterTaskLoopSimdDirective *D) {
2790 VisitOMPLoopDirective(D);
2791}
2792
2793void ASTStmtReader::VisitOMPMaskedTaskLoopSimdDirective(
2794 OMPMaskedTaskLoopSimdDirective *D) {
2795 VisitOMPLoopDirective(D);
2796}
2797
2798void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective(
2799 OMPParallelMasterTaskLoopDirective *D) {
2800 VisitOMPLoopDirective(D);
2801 D->setHasCancel(Record.readBool());
2802}
2803
2804void ASTStmtReader::VisitOMPParallelMaskedTaskLoopDirective(
2805 OMPParallelMaskedTaskLoopDirective *D) {
2806 VisitOMPLoopDirective(D);
2807 D->setHasCancel(Record.readBool());
2808}
2809
2810void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective(
2811 OMPParallelMasterTaskLoopSimdDirective *D) {
2812 VisitOMPLoopDirective(D);
2813}
2814
2815void ASTStmtReader::VisitOMPParallelMaskedTaskLoopSimdDirective(
2816 OMPParallelMaskedTaskLoopSimdDirective *D) {
2817 VisitOMPLoopDirective(D);
2818}
2819
2820void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2821 VisitOMPLoopDirective(D);
2822}
2823
2824void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2825 VisitStmt(S: D);
2826 VisitOMPExecutableDirective(E: D);
2827}
2828
2829void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2830 OMPDistributeParallelForDirective *D) {
2831 VisitOMPLoopDirective(D);
2832 D->setHasCancel(Record.readBool());
2833}
2834
2835void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2836 OMPDistributeParallelForSimdDirective *D) {
2837 VisitOMPLoopDirective(D);
2838}
2839
2840void ASTStmtReader::VisitOMPDistributeSimdDirective(
2841 OMPDistributeSimdDirective *D) {
2842 VisitOMPLoopDirective(D);
2843}
2844
2845void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2846 OMPTargetParallelForSimdDirective *D) {
2847 VisitOMPLoopDirective(D);
2848}
2849
2850void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2851 VisitOMPLoopDirective(D);
2852}
2853
2854void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2855 OMPTeamsDistributeDirective *D) {
2856 VisitOMPLoopDirective(D);
2857}
2858
2859void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2860 OMPTeamsDistributeSimdDirective *D) {
2861 VisitOMPLoopDirective(D);
2862}
2863
2864void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2865 OMPTeamsDistributeParallelForSimdDirective *D) {
2866 VisitOMPLoopDirective(D);
2867}
2868
2869void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2870 OMPTeamsDistributeParallelForDirective *D) {
2871 VisitOMPLoopDirective(D);
2872 D->setHasCancel(Record.readBool());
2873}
2874
2875void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2876 VisitStmt(S: D);
2877 VisitOMPExecutableDirective(E: D);
2878}
2879
2880void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2881 OMPTargetTeamsDistributeDirective *D) {
2882 VisitOMPLoopDirective(D);
2883}
2884
2885void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2886 OMPTargetTeamsDistributeParallelForDirective *D) {
2887 VisitOMPLoopDirective(D);
2888 D->setHasCancel(Record.readBool());
2889}
2890
2891void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2892 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2893 VisitOMPLoopDirective(D);
2894}
2895
2896void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2897 OMPTargetTeamsDistributeSimdDirective *D) {
2898 VisitOMPLoopDirective(D);
2899}
2900
2901void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) {
2902 VisitStmt(S: D);
2903 VisitOMPExecutableDirective(E: D);
2904}
2905
2906void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
2907 VisitStmt(S: D);
2908 VisitOMPExecutableDirective(E: D);
2909 D->setTargetCallLoc(Record.readSourceLocation());
2910}
2911
2912void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
2913 VisitStmt(S: D);
2914 VisitOMPExecutableDirective(E: D);
2915}
2916
2917void ASTStmtReader::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) {
2918 VisitOMPLoopDirective(D);
2919}
2920
2921void ASTStmtReader::VisitOMPTeamsGenericLoopDirective(
2922 OMPTeamsGenericLoopDirective *D) {
2923 VisitOMPLoopDirective(D);
2924}
2925
2926void ASTStmtReader::VisitOMPTargetTeamsGenericLoopDirective(
2927 OMPTargetTeamsGenericLoopDirective *D) {
2928 VisitOMPLoopDirective(D);
2929 D->setCanBeParallelFor(Record.readBool());
2930}
2931
2932void ASTStmtReader::VisitOMPParallelGenericLoopDirective(
2933 OMPParallelGenericLoopDirective *D) {
2934 VisitOMPLoopDirective(D);
2935}
2936
2937void ASTStmtReader::VisitOMPTargetParallelGenericLoopDirective(
2938 OMPTargetParallelGenericLoopDirective *D) {
2939 VisitOMPLoopDirective(D);
2940}
2941
2942//===----------------------------------------------------------------------===//
2943// OpenACC Constructs/Directives.
2944//===----------------------------------------------------------------------===//
2945void ASTStmtReader::VisitOpenACCConstructStmt(OpenACCConstructStmt *S) {
2946 (void)Record.readInt();
2947 S->Kind = Record.readEnum<OpenACCDirectiveKind>();
2948 S->Range = Record.readSourceRange();
2949 S->DirectiveLoc = Record.readSourceLocation();
2950 Record.readOpenACCClauseList(Clauses: S->Clauses);
2951}
2952
2953void ASTStmtReader::VisitOpenACCAssociatedStmtConstruct(
2954 OpenACCAssociatedStmtConstruct *S) {
2955 VisitOpenACCConstructStmt(S);
2956 S->setAssociatedStmt(Record.readSubStmt());
2957}
2958
2959void ASTStmtReader::VisitOpenACCComputeConstruct(OpenACCComputeConstruct *S) {
2960 VisitStmt(S);
2961 VisitOpenACCAssociatedStmtConstruct(S);
2962}
2963
2964void ASTStmtReader::VisitOpenACCLoopConstruct(OpenACCLoopConstruct *S) {
2965 VisitStmt(S);
2966 VisitOpenACCAssociatedStmtConstruct(S);
2967 S->ParentComputeConstructKind = Record.readEnum<OpenACCDirectiveKind>();
2968}
2969
2970void ASTStmtReader::VisitOpenACCCombinedConstruct(OpenACCCombinedConstruct *S) {
2971 VisitStmt(S);
2972 VisitOpenACCAssociatedStmtConstruct(S);
2973}
2974
2975void ASTStmtReader::VisitOpenACCDataConstruct(OpenACCDataConstruct *S) {
2976 VisitStmt(S);
2977 VisitOpenACCAssociatedStmtConstruct(S);
2978}
2979
2980void ASTStmtReader::VisitOpenACCEnterDataConstruct(
2981 OpenACCEnterDataConstruct *S) {
2982 VisitStmt(S);
2983 VisitOpenACCConstructStmt(S);
2984}
2985
2986void ASTStmtReader::VisitOpenACCExitDataConstruct(OpenACCExitDataConstruct *S) {
2987 VisitStmt(S);
2988 VisitOpenACCConstructStmt(S);
2989}
2990
2991void ASTStmtReader::VisitOpenACCInitConstruct(OpenACCInitConstruct *S) {
2992 VisitStmt(S);
2993 VisitOpenACCConstructStmt(S);
2994}
2995
2996void ASTStmtReader::VisitOpenACCShutdownConstruct(OpenACCShutdownConstruct *S) {
2997 VisitStmt(S);
2998 VisitOpenACCConstructStmt(S);
2999}
3000
3001void ASTStmtReader::VisitOpenACCSetConstruct(OpenACCSetConstruct *S) {
3002 VisitStmt(S);
3003 VisitOpenACCConstructStmt(S);
3004}
3005
3006void ASTStmtReader::VisitOpenACCUpdateConstruct(OpenACCUpdateConstruct *S) {
3007 VisitStmt(S);
3008 VisitOpenACCConstructStmt(S);
3009}
3010
3011void ASTStmtReader::VisitOpenACCHostDataConstruct(OpenACCHostDataConstruct *S) {
3012 VisitStmt(S);
3013 VisitOpenACCAssociatedStmtConstruct(S);
3014}
3015
3016void ASTStmtReader::VisitOpenACCWaitConstruct(OpenACCWaitConstruct *S) {
3017 VisitStmt(S);
3018 // Consume the count of Expressions.
3019 (void)Record.readInt();
3020 VisitOpenACCConstructStmt(S);
3021 S->LParenLoc = Record.readSourceLocation();
3022 S->RParenLoc = Record.readSourceLocation();
3023 S->QueuesLoc = Record.readSourceLocation();
3024
3025 for (unsigned I = 0; I < S->NumExprs; ++I) {
3026 S->getExprPtr()[I] = cast_if_present<Expr>(Val: Record.readSubStmt());
3027 assert((I == 0 || S->getExprPtr()[I] != nullptr) &&
3028 "Only first expression should be null");
3029 }
3030}
3031
3032void ASTStmtReader::VisitOpenACCCacheConstruct(OpenACCCacheConstruct *S) {
3033 VisitStmt(S);
3034 (void)Record.readInt();
3035 VisitOpenACCConstructStmt(S);
3036 S->ParensLoc = Record.readSourceRange();
3037 S->ReadOnlyLoc = Record.readSourceLocation();
3038 for (unsigned I = 0; I < S->NumVars; ++I)
3039 S->getVarList()[I] = cast<Expr>(Val: Record.readSubStmt());
3040}
3041
3042void ASTStmtReader::VisitOpenACCAtomicConstruct(OpenACCAtomicConstruct *S) {
3043 VisitStmt(S);
3044 VisitOpenACCConstructStmt(S);
3045 S->AtomicKind = Record.readEnum<OpenACCAtomicKind>();
3046 S->setAssociatedStmt(Record.readSubStmt());
3047}
3048
3049//===----------------------------------------------------------------------===//
3050// HLSL Constructs/Directives.
3051//===----------------------------------------------------------------------===//
3052
3053void ASTStmtReader::VisitHLSLOutArgExpr(HLSLOutArgExpr *S) {
3054 VisitExpr(E: S);
3055 S->SubExprs[HLSLOutArgExpr::BaseLValue] = Record.readSubExpr();
3056 S->SubExprs[HLSLOutArgExpr::CastedTemporary] = Record.readSubExpr();
3057 S->SubExprs[HLSLOutArgExpr::WritebackCast] = Record.readSubExpr();
3058 S->IsInOut = Record.readBool();
3059}
3060
3061//===----------------------------------------------------------------------===//
3062// ASTReader Implementation
3063//===----------------------------------------------------------------------===//
3064
3065Stmt *ASTReader::ReadStmt(ModuleFile &F) {
3066 switch (ReadingKind) {
3067 case Read_None:
3068 llvm_unreachable("should not call this when not reading anything");
3069 case Read_Decl:
3070 case Read_Type:
3071 return ReadStmtFromStream(F);
3072 case Read_Stmt:
3073 return ReadSubStmt();
3074 }
3075
3076 llvm_unreachable("ReadingKind not set ?");
3077}
3078
3079Expr *ASTReader::ReadExpr(ModuleFile &F) {
3080 return cast_or_null<Expr>(Val: ReadStmt(F));
3081}
3082
3083Expr *ASTReader::ReadSubExpr() {
3084 return cast_or_null<Expr>(Val: ReadSubStmt());
3085}
3086
3087// Within the bitstream, expressions are stored in Reverse Polish
3088// Notation, with each of the subexpressions preceding the
3089// expression they are stored in. Subexpressions are stored from last to first.
3090// To evaluate expressions, we continue reading expressions and placing them on
3091// the stack, with expressions having operands removing those operands from the
3092// stack. Evaluation terminates when we see a STMT_STOP record, and
3093// the single remaining expression on the stack is our result.
3094Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
3095 ReadingKindTracker ReadingKind(Read_Stmt, *this);
3096 llvm::BitstreamCursor &Cursor = F.DeclsCursor;
3097
3098 // Map of offset to previously deserialized stmt. The offset points
3099 // just after the stmt record.
3100 llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
3101
3102#ifndef NDEBUG
3103 unsigned PrevNumStmts = StmtStack.size();
3104#endif
3105
3106 ASTRecordReader Record(*this, F);
3107 ASTStmtReader Reader(Record, Cursor);
3108 Stmt::EmptyShell Empty;
3109
3110 while (true) {
3111 llvm::Expected<llvm::BitstreamEntry> MaybeEntry =
3112 Cursor.advanceSkippingSubblocks();
3113 if (!MaybeEntry) {
3114 Error(Msg: toString(E: MaybeEntry.takeError()));
3115 return nullptr;
3116 }
3117 llvm::BitstreamEntry Entry = MaybeEntry.get();
3118
3119 switch (Entry.Kind) {
3120 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
3121 case llvm::BitstreamEntry::Error:
3122 Error(Msg: "malformed block record in AST file");
3123 return nullptr;
3124 case llvm::BitstreamEntry::EndBlock:
3125 goto Done;
3126 case llvm::BitstreamEntry::Record:
3127 // The interesting case.
3128 break;
3129 }
3130
3131 ASTContext &Context = getContext();
3132 Stmt *S = nullptr;
3133 bool Finished = false;
3134 bool IsStmtReference = false;
3135 Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, AbbrevID: Entry.ID);
3136 if (!MaybeStmtCode) {
3137 Error(Msg: toString(E: MaybeStmtCode.takeError()));
3138 return nullptr;
3139 }
3140 switch ((StmtCode)MaybeStmtCode.get()) {
3141 case STMT_STOP:
3142 Finished = true;
3143 break;
3144
3145 case STMT_REF_PTR:
3146 IsStmtReference = true;
3147 assert(StmtEntries.contains(Record[0]) &&
3148 "No stmt was recorded for this offset reference!");
3149 S = StmtEntries[Record.readInt()];
3150 break;
3151
3152 case STMT_NULL_PTR:
3153 S = nullptr;
3154 break;
3155
3156 case STMT_NULL:
3157 S = new (Context) NullStmt(Empty);
3158 break;
3159
3160 case STMT_COMPOUND: {
3161 unsigned NumStmts = Record[ASTStmtReader::NumStmtFields];
3162 bool HasFPFeatures = Record[ASTStmtReader::NumStmtFields + 1];
3163 S = CompoundStmt::CreateEmpty(C: Context, NumStmts, HasFPFeatures);
3164 break;
3165 }
3166
3167 case STMT_CASE:
3168 S = CaseStmt::CreateEmpty(
3169 Ctx: Context,
3170 /*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]);
3171 break;
3172
3173 case STMT_DEFAULT:
3174 S = new (Context) DefaultStmt(Empty);
3175 break;
3176
3177 case STMT_LABEL:
3178 S = new (Context) LabelStmt(Empty);
3179 break;
3180
3181 case STMT_ATTRIBUTED:
3182 S = AttributedStmt::CreateEmpty(
3183 C: Context,
3184 /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
3185 break;
3186
3187 case STMT_IF: {
3188 BitsUnpacker IfStmtBits(Record[ASTStmtReader::NumStmtFields]);
3189 bool HasElse = IfStmtBits.getNextBit();
3190 bool HasVar = IfStmtBits.getNextBit();
3191 bool HasInit = IfStmtBits.getNextBit();
3192 S = IfStmt::CreateEmpty(Ctx: Context, HasElse, HasVar, HasInit);
3193 break;
3194 }
3195
3196 case STMT_SWITCH:
3197 S = SwitchStmt::CreateEmpty(
3198 Ctx: Context,
3199 /* HasInit=*/Record[ASTStmtReader::NumStmtFields],
3200 /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]);
3201 break;
3202
3203 case STMT_WHILE:
3204 S = WhileStmt::CreateEmpty(
3205 Ctx: Context,
3206 /* HasVar=*/Record[ASTStmtReader::NumStmtFields]);
3207 break;
3208
3209 case STMT_DO:
3210 S = new (Context) DoStmt(Empty);
3211 break;
3212
3213 case STMT_FOR:
3214 S = new (Context) ForStmt(Empty);
3215 break;
3216
3217 case STMT_GOTO:
3218 S = new (Context) GotoStmt(Empty);
3219 break;
3220
3221 case STMT_INDIRECT_GOTO:
3222 S = new (Context) IndirectGotoStmt(Empty);
3223 break;
3224
3225 case STMT_CONTINUE:
3226 S = new (Context) ContinueStmt(Empty);
3227 break;
3228
3229 case STMT_BREAK:
3230 S = new (Context) BreakStmt(Empty);
3231 break;
3232
3233 case STMT_DEFER:
3234 S = DeferStmt::CreateEmpty(Context, Empty);
3235 break;
3236
3237 case STMT_RETURN:
3238 S = ReturnStmt::CreateEmpty(
3239 Ctx: Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]);
3240 break;
3241
3242 case STMT_DECL:
3243 S = new (Context) DeclStmt(Empty);
3244 break;
3245
3246 case STMT_GCCASM:
3247 S = new (Context) GCCAsmStmt(Empty);
3248 break;
3249
3250 case STMT_MSASM:
3251 S = new (Context) MSAsmStmt(Empty);
3252 break;
3253
3254 case STMT_CAPTURED:
3255 S = CapturedStmt::CreateDeserialized(
3256 Context, NumCaptures: Record[ASTStmtReader::NumStmtFields]);
3257 break;
3258
3259 case STMT_SYCLKERNELCALL:
3260 S = new (Context) SYCLKernelCallStmt(Empty);
3261 break;
3262
3263 case EXPR_CONSTANT:
3264 S = ConstantExpr::CreateEmpty(
3265 Context, StorageKind: static_cast<ConstantResultStorageKind>(
3266 /*StorageKind=*/Record[ASTStmtReader::NumExprFields]));
3267 break;
3268
3269 case EXPR_SYCL_UNIQUE_STABLE_NAME:
3270 S = SYCLUniqueStableNameExpr::CreateEmpty(Ctx: Context);
3271 break;
3272
3273 case STMT_UNRESOLVED_SYCL_KERNEL_CALL:
3274 S = UnresolvedSYCLKernelCallStmt::CreateEmpty(C: Context);
3275 break;
3276
3277 case EXPR_OPENACC_ASTERISK_SIZE:
3278 S = OpenACCAsteriskSizeExpr::CreateEmpty(C: Context);
3279 break;
3280
3281 case EXPR_PREDEFINED:
3282 S = PredefinedExpr::CreateEmpty(
3283 Ctx: Context,
3284 /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]);
3285 break;
3286
3287 case EXPR_DECL_REF: {
3288 BitsUnpacker DeclRefExprBits(Record[ASTStmtReader::NumExprFields]);
3289 DeclRefExprBits.advance(BitsWidth: 5);
3290 bool HasFoundDecl = DeclRefExprBits.getNextBit();
3291 bool HasQualifier = DeclRefExprBits.getNextBit();
3292 bool HasTemplateKWAndArgsInfo = DeclRefExprBits.getNextBit();
3293 unsigned NumTemplateArgs = HasTemplateKWAndArgsInfo
3294 ? Record[ASTStmtReader::NumExprFields + 1]
3295 : 0;
3296 S = DeclRefExpr::CreateEmpty(Context, HasQualifier, HasFoundDecl,
3297 HasTemplateKWAndArgsInfo, NumTemplateArgs);
3298 break;
3299 }
3300
3301 case EXPR_INTEGER_LITERAL:
3302 S = IntegerLiteral::Create(C: Context, Empty);
3303 break;
3304
3305 case EXPR_FIXEDPOINT_LITERAL:
3306 S = FixedPointLiteral::Create(C: Context, Empty);
3307 break;
3308
3309 case EXPR_FLOATING_LITERAL:
3310 S = FloatingLiteral::Create(C: Context, Empty);
3311 break;
3312
3313 case EXPR_IMAGINARY_LITERAL:
3314 S = new (Context) ImaginaryLiteral(Empty);
3315 break;
3316
3317 case EXPR_STRING_LITERAL:
3318 S = StringLiteral::CreateEmpty(
3319 Ctx: Context,
3320 /* NumConcatenated=*/Record[ASTStmtReader::NumExprFields],
3321 /* Length=*/Record[ASTStmtReader::NumExprFields + 1],
3322 /* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]);
3323 break;
3324
3325 case EXPR_CHARACTER_LITERAL:
3326 S = new (Context) CharacterLiteral(Empty);
3327 break;
3328
3329 case EXPR_PAREN:
3330 S = new (Context) ParenExpr(Empty);
3331 break;
3332
3333 case EXPR_PAREN_LIST:
3334 S = ParenListExpr::CreateEmpty(
3335 Ctx: Context,
3336 /* NumExprs=*/Record[ASTStmtReader::NumExprFields]);
3337 break;
3338
3339 case EXPR_UNARY_OPERATOR: {
3340 BitsUnpacker UnaryOperatorBits(Record[ASTStmtReader::NumStmtFields]);
3341 UnaryOperatorBits.advance(BitsWidth: ASTStmtReader::NumExprBits);
3342 bool HasFPFeatures = UnaryOperatorBits.getNextBit();
3343 S = UnaryOperator::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3344 break;
3345 }
3346
3347 case EXPR_OFFSETOF:
3348 S = OffsetOfExpr::CreateEmpty(C: Context,
3349 NumComps: Record[ASTStmtReader::NumExprFields],
3350 NumExprs: Record[ASTStmtReader::NumExprFields + 1]);
3351 break;
3352
3353 case EXPR_SIZEOF_ALIGN_OF:
3354 S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
3355 break;
3356
3357 case EXPR_ARRAY_SUBSCRIPT:
3358 S = new (Context) ArraySubscriptExpr(Empty);
3359 break;
3360
3361 case EXPR_MATRIX_SUBSCRIPT:
3362 S = new (Context) MatrixSubscriptExpr(Empty);
3363 break;
3364
3365 case EXPR_ARRAY_SECTION:
3366 S = new (Context) ArraySectionExpr(Empty);
3367 break;
3368
3369 case EXPR_OMP_ARRAY_SHAPING:
3370 S = OMPArrayShapingExpr::CreateEmpty(
3371 Context, NumDims: Record[ASTStmtReader::NumExprFields]);
3372 break;
3373
3374 case EXPR_OMP_ITERATOR:
3375 S = OMPIteratorExpr::CreateEmpty(Context,
3376 NumIterators: Record[ASTStmtReader::NumExprFields]);
3377 break;
3378
3379 case EXPR_CALL: {
3380 auto NumArgs = Record[ASTStmtReader::NumExprFields];
3381 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
3382 CallExprBits.advance(BitsWidth: 1);
3383 auto HasFPFeatures = CallExprBits.getNextBit();
3384 S = CallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures, Empty);
3385 break;
3386 }
3387
3388 case EXPR_RECOVERY:
3389 S = RecoveryExpr::CreateEmpty(
3390 Ctx&: Context, /*NumArgs=*/NumSubExprs: Record[ASTStmtReader::NumExprFields]);
3391 break;
3392
3393 case EXPR_MEMBER: {
3394 BitsUnpacker ExprMemberBits(Record[ASTStmtReader::NumExprFields]);
3395 bool HasQualifier = ExprMemberBits.getNextBit();
3396 bool HasFoundDecl = ExprMemberBits.getNextBit();
3397 bool HasTemplateInfo = ExprMemberBits.getNextBit();
3398 unsigned NumTemplateArgs = Record[ASTStmtReader::NumExprFields + 1];
3399 S = MemberExpr::CreateEmpty(Context, HasQualifier, HasFoundDecl,
3400 HasTemplateKWAndArgsInfo: HasTemplateInfo, NumTemplateArgs);
3401 break;
3402 }
3403
3404 case EXPR_BINARY_OPERATOR: {
3405 BitsUnpacker BinaryOperatorBits(Record[ASTStmtReader::NumExprFields]);
3406 BinaryOperatorBits.advance(/*Size of opcode*/ BitsWidth: 6);
3407 bool HasFPFeatures = BinaryOperatorBits.getNextBit();
3408 S = BinaryOperator::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3409 break;
3410 }
3411
3412 case EXPR_COMPOUND_ASSIGN_OPERATOR: {
3413 BitsUnpacker BinaryOperatorBits(Record[ASTStmtReader::NumExprFields]);
3414 BinaryOperatorBits.advance(/*Size of opcode*/ BitsWidth: 6);
3415 bool HasFPFeatures = BinaryOperatorBits.getNextBit();
3416 S = CompoundAssignOperator::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3417 break;
3418 }
3419
3420 case EXPR_CONDITIONAL_OPERATOR:
3421 S = new (Context) ConditionalOperator(Empty);
3422 break;
3423
3424 case EXPR_BINARY_CONDITIONAL_OPERATOR:
3425 S = new (Context) BinaryConditionalOperator(Empty);
3426 break;
3427
3428 case EXPR_IMPLICIT_CAST: {
3429 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
3430 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
3431 CastExprBits.advance(BitsWidth: 7);
3432 bool HasFPFeatures = CastExprBits.getNextBit();
3433 S = ImplicitCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures);
3434 break;
3435 }
3436
3437 case EXPR_CSTYLE_CAST: {
3438 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
3439 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
3440 CastExprBits.advance(BitsWidth: 7);
3441 bool HasFPFeatures = CastExprBits.getNextBit();
3442 S = CStyleCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures);
3443 break;
3444 }
3445
3446 case EXPR_COMPOUND_LITERAL:
3447 S = new (Context) CompoundLiteralExpr(Empty);
3448 break;
3449
3450 case EXPR_EXT_VECTOR_ELEMENT:
3451 S = new (Context) ExtVectorElementExpr(Empty);
3452 break;
3453
3454 case EXPR_MATRIX_ELEMENT:
3455 S = new (Context) MatrixElementExpr(Empty);
3456 break;
3457
3458 case EXPR_INIT_LIST:
3459 S = new (Context) InitListExpr(Empty);
3460 break;
3461
3462 case EXPR_DESIGNATED_INIT:
3463 S = DesignatedInitExpr::CreateEmpty(C: Context,
3464 NumIndexExprs: Record[ASTStmtReader::NumExprFields] - 1);
3465
3466 break;
3467
3468 case EXPR_DESIGNATED_INIT_UPDATE:
3469 S = new (Context) DesignatedInitUpdateExpr(Empty);
3470 break;
3471
3472 case EXPR_IMPLICIT_VALUE_INIT:
3473 S = new (Context) ImplicitValueInitExpr(Empty);
3474 break;
3475
3476 case EXPR_NO_INIT:
3477 S = new (Context) NoInitExpr(Empty);
3478 break;
3479
3480 case EXPR_ARRAY_INIT_LOOP:
3481 S = new (Context) ArrayInitLoopExpr(Empty);
3482 break;
3483
3484 case EXPR_ARRAY_INIT_INDEX:
3485 S = new (Context) ArrayInitIndexExpr(Empty);
3486 break;
3487
3488 case EXPR_VA_ARG:
3489 S = new (Context) VAArgExpr(Empty);
3490 break;
3491
3492 case EXPR_SOURCE_LOC:
3493 S = new (Context) SourceLocExpr(Empty);
3494 break;
3495
3496 case EXPR_BUILTIN_PP_EMBED:
3497 S = new (Context) EmbedExpr(Empty);
3498 break;
3499
3500 case EXPR_ADDR_LABEL:
3501 S = new (Context) AddrLabelExpr(Empty);
3502 break;
3503
3504 case EXPR_STMT:
3505 S = new (Context) StmtExpr(Empty);
3506 break;
3507
3508 case EXPR_CHOOSE:
3509 S = new (Context) ChooseExpr(Empty);
3510 break;
3511
3512 case EXPR_GNU_NULL:
3513 S = new (Context) GNUNullExpr(Empty);
3514 break;
3515
3516 case EXPR_SHUFFLE_VECTOR:
3517 S = new (Context) ShuffleVectorExpr(Empty);
3518 break;
3519
3520 case EXPR_CONVERT_VECTOR: {
3521 BitsUnpacker ConvertVectorExprBits(Record[ASTStmtReader::NumStmtFields]);
3522 ConvertVectorExprBits.advance(BitsWidth: ASTStmtReader::NumExprBits);
3523 bool HasFPFeatures = ConvertVectorExprBits.getNextBit();
3524 S = ConvertVectorExpr::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3525 break;
3526 }
3527
3528 case EXPR_BLOCK:
3529 S = new (Context) BlockExpr(Empty);
3530 break;
3531
3532 case EXPR_GENERIC_SELECTION:
3533 S = GenericSelectionExpr::CreateEmpty(
3534 Context,
3535 /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
3536 break;
3537
3538 case EXPR_OBJC_STRING_LITERAL:
3539 S = new (Context) ObjCStringLiteral(Empty);
3540 break;
3541
3542 case EXPR_OBJC_BOXED_EXPRESSION:
3543 S = new (Context) ObjCBoxedExpr(Empty);
3544 break;
3545
3546 case EXPR_OBJC_ARRAY_LITERAL:
3547 S = ObjCArrayLiteral::CreateEmpty(
3548 C: Context, NumElements: Record[ASTStmtReader::NumObjCObjectLiteralFields]);
3549 break;
3550
3551 case EXPR_OBJC_DICTIONARY_LITERAL:
3552 S = ObjCDictionaryLiteral::CreateEmpty(
3553 C: Context, NumElements: Record[ASTStmtReader::NumObjCObjectLiteralFields],
3554 HasPackExpansions: Record[ASTStmtReader::NumObjCObjectLiteralFields + 1]);
3555 break;
3556
3557 case EXPR_OBJC_ENCODE:
3558 S = new (Context) ObjCEncodeExpr(Empty);
3559 break;
3560
3561 case EXPR_OBJC_SELECTOR_EXPR:
3562 S = new (Context) ObjCSelectorExpr(Empty);
3563 break;
3564
3565 case EXPR_OBJC_PROTOCOL_EXPR:
3566 S = new (Context) ObjCProtocolExpr(Empty);
3567 break;
3568
3569 case EXPR_OBJC_IVAR_REF_EXPR:
3570 S = new (Context) ObjCIvarRefExpr(Empty);
3571 break;
3572
3573 case EXPR_OBJC_PROPERTY_REF_EXPR:
3574 S = new (Context) ObjCPropertyRefExpr(Empty);
3575 break;
3576
3577 case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
3578 S = new (Context) ObjCSubscriptRefExpr(Empty);
3579 break;
3580
3581 case EXPR_OBJC_KVC_REF_EXPR:
3582 llvm_unreachable("mismatching AST file");
3583
3584 case EXPR_OBJC_MESSAGE_EXPR:
3585 S = ObjCMessageExpr::CreateEmpty(Context,
3586 NumArgs: Record[ASTStmtReader::NumExprFields],
3587 NumStoredSelLocs: Record[ASTStmtReader::NumExprFields + 1]);
3588 break;
3589
3590 case EXPR_OBJC_ISA:
3591 S = new (Context) ObjCIsaExpr(Empty);
3592 break;
3593
3594 case EXPR_OBJC_INDIRECT_COPY_RESTORE:
3595 S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3596 break;
3597
3598 case EXPR_OBJC_BRIDGED_CAST:
3599 S = new (Context) ObjCBridgedCastExpr(Empty);
3600 break;
3601
3602 case STMT_OBJC_FOR_COLLECTION:
3603 S = new (Context) ObjCForCollectionStmt(Empty);
3604 break;
3605
3606 case STMT_OBJC_CATCH:
3607 S = new (Context) ObjCAtCatchStmt(Empty);
3608 break;
3609
3610 case STMT_OBJC_FINALLY:
3611 S = new (Context) ObjCAtFinallyStmt(Empty);
3612 break;
3613
3614 case STMT_OBJC_AT_TRY:
3615 S = ObjCAtTryStmt::CreateEmpty(Context,
3616 NumCatchStmts: Record[ASTStmtReader::NumStmtFields],
3617 HasFinally: Record[ASTStmtReader::NumStmtFields + 1]);
3618 break;
3619
3620 case STMT_OBJC_AT_SYNCHRONIZED:
3621 S = new (Context) ObjCAtSynchronizedStmt(Empty);
3622 break;
3623
3624 case STMT_OBJC_AT_THROW:
3625 S = new (Context) ObjCAtThrowStmt(Empty);
3626 break;
3627
3628 case STMT_OBJC_AUTORELEASE_POOL:
3629 S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3630 break;
3631
3632 case EXPR_OBJC_BOOL_LITERAL:
3633 S = new (Context) ObjCBoolLiteralExpr(Empty);
3634 break;
3635
3636 case EXPR_OBJC_AVAILABILITY_CHECK:
3637 S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3638 break;
3639
3640 case STMT_SEH_LEAVE:
3641 S = new (Context) SEHLeaveStmt(Empty);
3642 break;
3643
3644 case STMT_SEH_EXCEPT:
3645 S = new (Context) SEHExceptStmt(Empty);
3646 break;
3647
3648 case STMT_SEH_FINALLY:
3649 S = new (Context) SEHFinallyStmt(Empty);
3650 break;
3651
3652 case STMT_SEH_TRY:
3653 S = new (Context) SEHTryStmt(Empty);
3654 break;
3655
3656 case STMT_CXX_CATCH:
3657 S = new (Context) CXXCatchStmt(Empty);
3658 break;
3659
3660 case STMT_CXX_TRY:
3661 S = CXXTryStmt::Create(C: Context, Empty,
3662 /*numHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3663 break;
3664
3665 case STMT_CXX_EXPANSION_PATTERN:
3666 S = CXXExpansionStmtPattern::CreateEmpty(
3667 Context, Empty,
3668 Kind: static_cast<CXXExpansionStmtPattern::ExpansionStmtKind>(
3669 Record[ASTStmtReader::NumStmtFields]));
3670 break;
3671
3672 case STMT_CXX_EXPANSION_INSTANTIATION:
3673 S = CXXExpansionStmtInstantiation::CreateEmpty(
3674 C&: Context, Empty, NumInstantiations: Record[ASTStmtReader::NumStmtFields],
3675 NumPreambleStmts: Record[ASTStmtReader::NumStmtFields + 1]);
3676 break;
3677
3678 case STMT_CXX_FOR_RANGE:
3679 S = new (Context) CXXForRangeStmt(Empty);
3680 break;
3681
3682 case STMT_MS_DEPENDENT_EXISTS:
3683 S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3684 NestedNameSpecifierLoc(),
3685 DeclarationNameInfo(),
3686 nullptr);
3687 break;
3688
3689 case STMT_OMP_CANONICAL_LOOP:
3690 S = OMPCanonicalLoop::createEmpty(Ctx: Context);
3691 break;
3692
3693 case STMT_OMP_META_DIRECTIVE:
3694 S = OMPMetaDirective::CreateEmpty(
3695 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3696 break;
3697
3698 case STMT_OMP_PARALLEL_DIRECTIVE:
3699 S =
3700 OMPParallelDirective::CreateEmpty(C: Context,
3701 NumClauses: Record[ASTStmtReader::NumStmtFields],
3702 Empty);
3703 break;
3704
3705 case STMT_OMP_SIMD_DIRECTIVE: {
3706 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3707 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3708 S = OMPSimdDirective::CreateEmpty(C: Context, NumClauses,
3709 CollapsedNum, Empty);
3710 break;
3711 }
3712
3713 case STMT_OMP_TILE_DIRECTIVE: {
3714 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3715 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3716 S = OMPTileDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3717 break;
3718 }
3719
3720 case STMP_OMP_STRIPE_DIRECTIVE: {
3721 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3722 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3723 S = OMPStripeDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3724 break;
3725 }
3726
3727 case STMT_OMP_UNROLL_DIRECTIVE: {
3728 assert(Record[ASTStmtReader::NumStmtFields] == 1 && "Unroll directive accepts only a single loop");
3729 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3730 S = OMPUnrollDirective::CreateEmpty(C: Context, NumClauses);
3731 break;
3732 }
3733
3734 case STMT_OMP_REVERSE_DIRECTIVE: {
3735 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3736 assert(Record[ASTStmtReader::NumStmtFields + 1] == 0 &&
3737 "Reverse directive has no clauses");
3738 S = OMPReverseDirective::CreateEmpty(C: Context, NumLoops);
3739 break;
3740 }
3741
3742 case STMT_OMP_SPLIT_DIRECTIVE: {
3743 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3744 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3745 S = OMPSplitDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3746 break;
3747 }
3748
3749 case STMT_OMP_FUSE_DIRECTIVE: {
3750 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3751 S = OMPFuseDirective::CreateEmpty(C: Context, NumClauses);
3752 break;
3753 }
3754
3755 case STMT_OMP_INTERCHANGE_DIRECTIVE: {
3756 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3757 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3758 S = OMPInterchangeDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3759 break;
3760 }
3761
3762 case STMT_OMP_FOR_DIRECTIVE: {
3763 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3764 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3765 S = OMPForDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3766 Empty);
3767 break;
3768 }
3769
3770 case STMT_OMP_FOR_SIMD_DIRECTIVE: {
3771 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3772 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3773 S = OMPForSimdDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3774 Empty);
3775 break;
3776 }
3777
3778 case STMT_OMP_SECTIONS_DIRECTIVE:
3779 S = OMPSectionsDirective::CreateEmpty(
3780 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3781 break;
3782
3783 case STMT_OMP_SECTION_DIRECTIVE:
3784 S = OMPSectionDirective::CreateEmpty(C: Context, Empty);
3785 break;
3786
3787 case STMT_OMP_SCOPE_DIRECTIVE:
3788 S = OMPScopeDirective::CreateEmpty(
3789 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3790 break;
3791
3792 case STMT_OMP_SINGLE_DIRECTIVE:
3793 S = OMPSingleDirective::CreateEmpty(
3794 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3795 break;
3796
3797 case STMT_OMP_MASTER_DIRECTIVE:
3798 S = OMPMasterDirective::CreateEmpty(C: Context, Empty);
3799 break;
3800
3801 case STMT_OMP_CRITICAL_DIRECTIVE:
3802 S = OMPCriticalDirective::CreateEmpty(
3803 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3804 break;
3805
3806 case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
3807 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3808 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3809 S = OMPParallelForDirective::CreateEmpty(C: Context, NumClauses,
3810 CollapsedNum, Empty);
3811 break;
3812 }
3813
3814 case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
3815 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3816 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3817 S = OMPParallelForSimdDirective::CreateEmpty(C: Context, NumClauses,
3818 CollapsedNum, Empty);
3819 break;
3820 }
3821
3822 case STMT_OMP_PARALLEL_MASTER_DIRECTIVE:
3823 S = OMPParallelMasterDirective::CreateEmpty(
3824 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3825 break;
3826
3827 case STMT_OMP_PARALLEL_MASKED_DIRECTIVE:
3828 S = OMPParallelMaskedDirective::CreateEmpty(
3829 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3830 break;
3831
3832 case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
3833 S = OMPParallelSectionsDirective::CreateEmpty(
3834 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3835 break;
3836
3837 case STMT_OMP_TASK_DIRECTIVE:
3838 S = OMPTaskDirective::CreateEmpty(
3839 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3840 break;
3841
3842 case STMT_OMP_TASKYIELD_DIRECTIVE:
3843 S = OMPTaskyieldDirective::CreateEmpty(C: Context, Empty);
3844 break;
3845
3846 case STMT_OMP_BARRIER_DIRECTIVE:
3847 S = OMPBarrierDirective::CreateEmpty(C: Context, Empty);
3848 break;
3849
3850 case STMT_OMP_TASKWAIT_DIRECTIVE:
3851 S = OMPTaskwaitDirective::CreateEmpty(
3852 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3853 break;
3854
3855 case STMT_OMP_ERROR_DIRECTIVE:
3856 S = OMPErrorDirective::CreateEmpty(
3857 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3858 break;
3859
3860 case STMT_OMP_TASKGROUP_DIRECTIVE:
3861 S = OMPTaskgroupDirective::CreateEmpty(
3862 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3863 break;
3864
3865 case STMT_OMP_FLUSH_DIRECTIVE:
3866 S = OMPFlushDirective::CreateEmpty(
3867 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3868 break;
3869
3870 case STMT_OMP_DEPOBJ_DIRECTIVE:
3871 S = OMPDepobjDirective::CreateEmpty(
3872 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3873 break;
3874
3875 case STMT_OMP_SCAN_DIRECTIVE:
3876 S = OMPScanDirective::CreateEmpty(
3877 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3878 break;
3879
3880 case STMT_OMP_ORDERED_DIRECTIVE: {
3881 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3882 bool HasAssociatedStmt = Record[ASTStmtReader::NumStmtFields + 2];
3883 S = OMPOrderedDirective::CreateEmpty(C: Context, NumClauses,
3884 IsStandalone: !HasAssociatedStmt, Empty);
3885 break;
3886 }
3887
3888 case STMT_OMP_ATOMIC_DIRECTIVE:
3889 S = OMPAtomicDirective::CreateEmpty(
3890 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3891 break;
3892
3893 case STMT_OMP_TARGET_DIRECTIVE:
3894 S = OMPTargetDirective::CreateEmpty(
3895 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3896 break;
3897
3898 case STMT_OMP_TARGET_DATA_DIRECTIVE:
3899 S = OMPTargetDataDirective::CreateEmpty(
3900 C: Context, N: Record[ASTStmtReader::NumStmtFields], Empty);
3901 break;
3902
3903 case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE:
3904 S = OMPTargetEnterDataDirective::CreateEmpty(
3905 C: Context, N: Record[ASTStmtReader::NumStmtFields], Empty);
3906 break;
3907
3908 case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE:
3909 S = OMPTargetExitDataDirective::CreateEmpty(
3910 C: Context, N: Record[ASTStmtReader::NumStmtFields], Empty);
3911 break;
3912
3913 case STMT_OMP_TARGET_PARALLEL_DIRECTIVE:
3914 S = OMPTargetParallelDirective::CreateEmpty(
3915 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3916 break;
3917
3918 case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: {
3919 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3920 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3921 S = OMPTargetParallelForDirective::CreateEmpty(C: Context, NumClauses,
3922 CollapsedNum, Empty);
3923 break;
3924 }
3925
3926 case STMT_OMP_TARGET_UPDATE_DIRECTIVE:
3927 S = OMPTargetUpdateDirective::CreateEmpty(
3928 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3929 break;
3930
3931 case STMT_OMP_TEAMS_DIRECTIVE:
3932 S = OMPTeamsDirective::CreateEmpty(
3933 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3934 break;
3935
3936 case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
3937 S = OMPCancellationPointDirective::CreateEmpty(C: Context, Empty);
3938 break;
3939
3940 case STMT_OMP_CANCEL_DIRECTIVE:
3941 S = OMPCancelDirective::CreateEmpty(
3942 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3943 break;
3944
3945 case STMT_OMP_TASKLOOP_DIRECTIVE: {
3946 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3947 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3948 S = OMPTaskLoopDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3949 Empty);
3950 break;
3951 }
3952
3953 case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
3954 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3955 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3956 S = OMPTaskLoopSimdDirective::CreateEmpty(C: Context, NumClauses,
3957 CollapsedNum, Empty);
3958 break;
3959 }
3960
3961 case STMT_OMP_MASTER_TASKLOOP_DIRECTIVE: {
3962 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3963 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3964 S = OMPMasterTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
3965 CollapsedNum, Empty);
3966 break;
3967 }
3968
3969 case STMT_OMP_MASKED_TASKLOOP_DIRECTIVE: {
3970 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3971 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3972 S = OMPMaskedTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
3973 CollapsedNum, Empty);
3974 break;
3975 }
3976
3977 case STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
3978 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3979 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3980 S = OMPMasterTaskLoopSimdDirective::CreateEmpty(C: Context, NumClauses,
3981 CollapsedNum, Empty);
3982 break;
3983 }
3984
3985 case STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE: {
3986 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3987 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3988 S = OMPMaskedTaskLoopSimdDirective::CreateEmpty(C: Context, NumClauses,
3989 CollapsedNum, Empty);
3990 break;
3991 }
3992
3993 case STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE: {
3994 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3995 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3996 S = OMPParallelMasterTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
3997 CollapsedNum, Empty);
3998 break;
3999 }
4000
4001 case STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE: {
4002 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4003 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4004 S = OMPParallelMaskedTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
4005 CollapsedNum, Empty);
4006 break;
4007 }
4008
4009 case STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
4010 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4011 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4012 S = OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(
4013 C: Context, NumClauses, CollapsedNum, Empty);
4014 break;
4015 }
4016
4017 case STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE: {
4018 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4019 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4020 S = OMPParallelMaskedTaskLoopSimdDirective::CreateEmpty(
4021 C: Context, NumClauses, CollapsedNum, Empty);
4022 break;
4023 }
4024
4025 case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
4026 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4027 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4028 S = OMPDistributeDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
4029 Empty);
4030 break;
4031 }
4032
4033 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
4034 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4035 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4036 S = OMPDistributeParallelForDirective::CreateEmpty(C: Context, NumClauses,
4037 CollapsedNum, Empty);
4038 break;
4039 }
4040
4041 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
4042 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4043 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4044 S = OMPDistributeParallelForSimdDirective::CreateEmpty(C: Context, NumClauses,
4045 CollapsedNum,
4046 Empty);
4047 break;
4048 }
4049
4050 case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: {
4051 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4052 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4053 S = OMPDistributeSimdDirective::CreateEmpty(C: Context, NumClauses,
4054 CollapsedNum, Empty);
4055 break;
4056 }
4057
4058 case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: {
4059 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4060 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4061 S = OMPTargetParallelForSimdDirective::CreateEmpty(C: Context, NumClauses,
4062 CollapsedNum, Empty);
4063 break;
4064 }
4065
4066 case STMT_OMP_TARGET_SIMD_DIRECTIVE: {
4067 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4068 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4069 S = OMPTargetSimdDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
4070 Empty);
4071 break;
4072 }
4073
4074 case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: {
4075 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4076 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4077 S = OMPTeamsDistributeDirective::CreateEmpty(C: Context, NumClauses,
4078 CollapsedNum, Empty);
4079 break;
4080 }
4081
4082 case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
4083 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4084 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4085 S = OMPTeamsDistributeSimdDirective::CreateEmpty(C: Context, NumClauses,
4086 CollapsedNum, Empty);
4087 break;
4088 }
4089
4090 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
4091 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4092 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4093 S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(
4094 C: Context, NumClauses, CollapsedNum, Empty);
4095 break;
4096 }
4097
4098 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
4099 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4100 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4101 S = OMPTeamsDistributeParallelForDirective::CreateEmpty(
4102 C: Context, NumClauses, CollapsedNum, Empty);
4103 break;
4104 }
4105
4106 case STMT_OMP_TARGET_TEAMS_DIRECTIVE:
4107 S = OMPTargetTeamsDirective::CreateEmpty(
4108 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4109 break;
4110
4111 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: {
4112 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4113 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4114 S = OMPTargetTeamsDistributeDirective::CreateEmpty(C: Context, NumClauses,
4115 CollapsedNum, Empty);
4116 break;
4117 }
4118
4119 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
4120 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4121 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4122 S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(
4123 C: Context, NumClauses, CollapsedNum, Empty);
4124 break;
4125 }
4126
4127 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
4128 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4129 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4130 S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
4131 C: Context, NumClauses, CollapsedNum, Empty);
4132 break;
4133 }
4134
4135 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
4136 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4137 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4138 S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty(
4139 C: Context, NumClauses, CollapsedNum, Empty);
4140 break;
4141 }
4142
4143 case STMT_OMP_INTEROP_DIRECTIVE:
4144 S = OMPInteropDirective::CreateEmpty(
4145 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4146 break;
4147
4148 case STMT_OMP_DISPATCH_DIRECTIVE:
4149 S = OMPDispatchDirective::CreateEmpty(
4150 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4151 break;
4152
4153 case STMT_OMP_MASKED_DIRECTIVE:
4154 S = OMPMaskedDirective::CreateEmpty(
4155 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4156 break;
4157
4158 case STMT_OMP_GENERIC_LOOP_DIRECTIVE: {
4159 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4160 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4161 S = OMPGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4162 CollapsedNum, Empty);
4163 break;
4164 }
4165
4166 case STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE: {
4167 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4168 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4169 S = OMPTeamsGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4170 CollapsedNum, Empty);
4171 break;
4172 }
4173
4174 case STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE: {
4175 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4176 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4177 S = OMPTargetTeamsGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4178 CollapsedNum, Empty);
4179 break;
4180 }
4181
4182 case STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE: {
4183 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4184 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4185 S = OMPParallelGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4186 CollapsedNum, Empty);
4187 break;
4188 }
4189
4190 case STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE: {
4191 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4192 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4193 S = OMPTargetParallelGenericLoopDirective::CreateEmpty(
4194 C: Context, NumClauses, CollapsedNum, Empty);
4195 break;
4196 }
4197
4198 case STMT_OMP_ASSUME_DIRECTIVE: {
4199 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4200 S = OMPAssumeDirective::CreateEmpty(C: Context, NumClauses, Empty);
4201 break;
4202 }
4203
4204 case EXPR_CXX_OPERATOR_CALL: {
4205 auto NumArgs = Record[ASTStmtReader::NumExprFields];
4206 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4207 CallExprBits.advance(BitsWidth: 1);
4208 auto HasFPFeatures = CallExprBits.getNextBit();
4209 S = CXXOperatorCallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures,
4210 Empty);
4211 break;
4212 }
4213
4214 case EXPR_CXX_MEMBER_CALL: {
4215 auto NumArgs = Record[ASTStmtReader::NumExprFields];
4216 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4217 CallExprBits.advance(BitsWidth: 1);
4218 auto HasFPFeatures = CallExprBits.getNextBit();
4219 S = CXXMemberCallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures,
4220 Empty);
4221 break;
4222 }
4223
4224 case EXPR_CXX_REWRITTEN_BINARY_OPERATOR:
4225 S = new (Context) CXXRewrittenBinaryOperator(Empty);
4226 break;
4227
4228 case EXPR_CXX_CONSTRUCT:
4229 S = CXXConstructExpr::CreateEmpty(
4230 Ctx: Context,
4231 /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
4232 break;
4233
4234 case EXPR_CXX_INHERITED_CTOR_INIT:
4235 S = new (Context) CXXInheritedCtorInitExpr(Empty);
4236 break;
4237
4238 case EXPR_CXX_TEMPORARY_OBJECT:
4239 S = CXXTemporaryObjectExpr::CreateEmpty(
4240 Ctx: Context,
4241 /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
4242 break;
4243
4244 case EXPR_CXX_STATIC_CAST: {
4245 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4246 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4247 CastExprBits.advance(BitsWidth: 7);
4248 bool HasFPFeatures = CastExprBits.getNextBit();
4249 S = CXXStaticCastExpr::CreateEmpty(Context, PathSize, hasFPFeatures: HasFPFeatures);
4250 break;
4251 }
4252
4253 case EXPR_CXX_DYNAMIC_CAST: {
4254 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4255 S = CXXDynamicCastExpr::CreateEmpty(Context, pathSize: PathSize);
4256 break;
4257 }
4258
4259 case EXPR_CXX_REINTERPRET_CAST: {
4260 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4261 S = CXXReinterpretCastExpr::CreateEmpty(Context, pathSize: PathSize);
4262 break;
4263 }
4264
4265 case EXPR_CXX_CONST_CAST:
4266 S = CXXConstCastExpr::CreateEmpty(Context);
4267 break;
4268
4269 case EXPR_CXX_ADDRSPACE_CAST:
4270 S = CXXAddrspaceCastExpr::CreateEmpty(Context);
4271 break;
4272
4273 case EXPR_CXX_FUNCTIONAL_CAST: {
4274 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4275 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4276 CastExprBits.advance(BitsWidth: 7);
4277 bool HasFPFeatures = CastExprBits.getNextBit();
4278 S = CXXFunctionalCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures);
4279 break;
4280 }
4281
4282 case EXPR_BUILTIN_BIT_CAST: {
4283#ifndef NDEBUG
4284 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4285 assert(PathSize == 0 && "Wrong PathSize!");
4286#endif
4287 S = new (Context) BuiltinBitCastExpr(Empty);
4288 break;
4289 }
4290
4291 case EXPR_USER_DEFINED_LITERAL: {
4292 auto NumArgs = Record[ASTStmtReader::NumExprFields];
4293 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4294 CallExprBits.advance(BitsWidth: 1);
4295 auto HasFPFeatures = CallExprBits.getNextBit();
4296 S = UserDefinedLiteral::CreateEmpty(Ctx: Context, NumArgs, HasFPOptions: HasFPFeatures,
4297 Empty);
4298 break;
4299 }
4300
4301 case EXPR_CXX_STD_INITIALIZER_LIST:
4302 S = new (Context) CXXStdInitializerListExpr(Empty);
4303 break;
4304
4305 case EXPR_CXX_BOOL_LITERAL:
4306 S = new (Context) CXXBoolLiteralExpr(Empty);
4307 break;
4308
4309 case EXPR_CXX_NULL_PTR_LITERAL:
4310 S = new (Context) CXXNullPtrLiteralExpr(Empty);
4311 break;
4312
4313 case EXPR_CXX_TYPEID_EXPR:
4314 S = new (Context) CXXTypeidExpr(Empty, true);
4315 break;
4316
4317 case EXPR_CXX_TYPEID_TYPE:
4318 S = new (Context) CXXTypeidExpr(Empty, false);
4319 break;
4320
4321 case EXPR_CXX_UUIDOF_EXPR:
4322 S = new (Context) CXXUuidofExpr(Empty, true);
4323 break;
4324
4325 case EXPR_CXX_PROPERTY_REF_EXPR:
4326 S = new (Context) MSPropertyRefExpr(Empty);
4327 break;
4328
4329 case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
4330 S = new (Context) MSPropertySubscriptExpr(Empty);
4331 break;
4332
4333 case EXPR_CXX_UUIDOF_TYPE:
4334 S = new (Context) CXXUuidofExpr(Empty, false);
4335 break;
4336
4337 case EXPR_CXX_THIS:
4338 S = CXXThisExpr::CreateEmpty(Ctx: Context);
4339 break;
4340
4341 case EXPR_CXX_THROW:
4342 S = new (Context) CXXThrowExpr(Empty);
4343 break;
4344
4345 case EXPR_CXX_DEFAULT_ARG:
4346 S = CXXDefaultArgExpr::CreateEmpty(
4347 C: Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
4348 break;
4349
4350 case EXPR_CXX_DEFAULT_INIT:
4351 S = CXXDefaultInitExpr::CreateEmpty(
4352 C: Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
4353 break;
4354
4355 case EXPR_CXX_BIND_TEMPORARY:
4356 S = new (Context) CXXBindTemporaryExpr(Empty);
4357 break;
4358
4359 case EXPR_CXX_SCALAR_VALUE_INIT:
4360 S = new (Context) CXXScalarValueInitExpr(Empty);
4361 break;
4362
4363 case EXPR_CXX_NEW:
4364 S = CXXNewExpr::CreateEmpty(
4365 Ctx: Context,
4366 /*IsArray=*/Record[ASTStmtReader::NumExprFields],
4367 /*HasInit=*/Record[ASTStmtReader::NumExprFields + 1],
4368 /*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2],
4369 /*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]);
4370 break;
4371
4372 case EXPR_CXX_DELETE:
4373 S = new (Context) CXXDeleteExpr(Empty);
4374 break;
4375
4376 case EXPR_CXX_PSEUDO_DESTRUCTOR:
4377 S = new (Context) CXXPseudoDestructorExpr(Empty);
4378 break;
4379
4380 case EXPR_EXPR_WITH_CLEANUPS:
4381 S = ExprWithCleanups::Create(C: Context, empty: Empty,
4382 numObjects: Record[ASTStmtReader::NumExprFields]);
4383 break;
4384
4385 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: {
4386 unsigned NumTemplateArgs = Record[ASTStmtReader::NumExprFields];
4387 BitsUnpacker DependentScopeMemberBits(
4388 Record[ASTStmtReader::NumExprFields + 1]);
4389 bool HasTemplateKWAndArgsInfo = DependentScopeMemberBits.getNextBit();
4390
4391 bool HasFirstQualifierFoundInScope =
4392 DependentScopeMemberBits.getNextBit();
4393 S = CXXDependentScopeMemberExpr::CreateEmpty(
4394 Ctx: Context, HasTemplateKWAndArgsInfo, NumTemplateArgs,
4395 HasFirstQualifierFoundInScope);
4396 break;
4397 }
4398
4399 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: {
4400 BitsUnpacker DependentScopeDeclRefBits(
4401 Record[ASTStmtReader::NumStmtFields]);
4402 DependentScopeDeclRefBits.advance(BitsWidth: ASTStmtReader::NumExprBits);
4403 bool HasTemplateKWAndArgsInfo = DependentScopeDeclRefBits.getNextBit();
4404 unsigned NumTemplateArgs =
4405 HasTemplateKWAndArgsInfo
4406 ? DependentScopeDeclRefBits.getNextBits(/*Width=*/16)
4407 : 0;
4408 S = DependentScopeDeclRefExpr::CreateEmpty(
4409 Context, HasTemplateKWAndArgsInfo, NumTemplateArgs);
4410 break;
4411 }
4412
4413 case EXPR_CXX_UNRESOLVED_CONSTRUCT:
4414 S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
4415 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
4416 break;
4417
4418 case EXPR_CXX_UNRESOLVED_MEMBER: {
4419 auto NumResults = Record[ASTStmtReader::NumExprFields];
4420 BitsUnpacker OverloadExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4421 auto HasTemplateKWAndArgsInfo = OverloadExprBits.getNextBit();
4422 auto NumTemplateArgs = HasTemplateKWAndArgsInfo
4423 ? Record[ASTStmtReader::NumExprFields + 2]
4424 : 0;
4425 S = UnresolvedMemberExpr::CreateEmpty(
4426 Context, NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
4427 break;
4428 }
4429
4430 case EXPR_CXX_UNRESOLVED_LOOKUP: {
4431 auto NumResults = Record[ASTStmtReader::NumExprFields];
4432 BitsUnpacker OverloadExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4433 auto HasTemplateKWAndArgsInfo = OverloadExprBits.getNextBit();
4434 auto NumTemplateArgs = HasTemplateKWAndArgsInfo
4435 ? Record[ASTStmtReader::NumExprFields + 2]
4436 : 0;
4437 S = UnresolvedLookupExpr::CreateEmpty(
4438 Context, NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
4439 break;
4440 }
4441
4442 case EXPR_TYPE_TRAIT:
4443 S = TypeTraitExpr::CreateDeserialized(
4444 C: Context, IsStoredAsBool: Record[ASTStmtReader::NumExprFields],
4445 NumArgs: Record[ASTStmtReader::NumExprFields + 1]);
4446 break;
4447
4448 case EXPR_ARRAY_TYPE_TRAIT:
4449 S = new (Context) ArrayTypeTraitExpr(Empty);
4450 break;
4451
4452 case EXPR_CXX_EXPRESSION_TRAIT:
4453 S = new (Context) ExpressionTraitExpr(Empty);
4454 break;
4455
4456 case EXPR_CXX_NOEXCEPT:
4457 S = new (Context) CXXNoexceptExpr(Empty);
4458 break;
4459
4460 case EXPR_PACK_EXPANSION:
4461 S = new (Context) PackExpansionExpr(Empty);
4462 break;
4463
4464 case EXPR_SIZEOF_PACK:
4465 S = SizeOfPackExpr::CreateDeserialized(
4466 Context,
4467 /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
4468 break;
4469
4470 case EXPR_PACK_INDEXING:
4471 S = PackIndexingExpr::CreateDeserialized(
4472 Context,
4473 /*TransformedExprs=*/NumTransformedExprs: Record[ASTStmtReader::NumExprFields]);
4474 break;
4475
4476 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
4477 S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
4478 break;
4479
4480 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
4481 S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
4482 break;
4483
4484 case EXPR_FUNCTION_PARM_PACK:
4485 S = FunctionParmPackExpr::CreateEmpty(Context,
4486 NumParams: Record[ASTStmtReader::NumExprFields]);
4487 break;
4488
4489 case EXPR_MATERIALIZE_TEMPORARY:
4490 S = new (Context) MaterializeTemporaryExpr(Empty);
4491 break;
4492
4493 case EXPR_CXX_FOLD:
4494 S = new (Context) CXXFoldExpr(Empty);
4495 break;
4496
4497 case EXPR_CXX_PAREN_LIST_INIT:
4498 S = CXXParenListInitExpr::CreateEmpty(
4499 C&: Context, /*numExprs=*/Record[ASTStmtReader::NumExprFields], Empty);
4500 break;
4501
4502 case EXPR_OPAQUE_VALUE:
4503 S = new (Context) OpaqueValueExpr(Empty);
4504 break;
4505
4506 case EXPR_CUDA_KERNEL_CALL: {
4507 auto NumArgs = Record[ASTStmtReader::NumExprFields];
4508 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4509 CallExprBits.advance(BitsWidth: 1);
4510 auto HasFPFeatures = CallExprBits.getNextBit();
4511 S = CUDAKernelCallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures,
4512 Empty);
4513 break;
4514 }
4515
4516 case EXPR_ASTYPE:
4517 S = new (Context) AsTypeExpr(Empty);
4518 break;
4519
4520 case EXPR_PSEUDO_OBJECT: {
4521 unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
4522 S = PseudoObjectExpr::Create(Context, shell: Empty, numSemanticExprs);
4523 break;
4524 }
4525
4526 case EXPR_ATOMIC:
4527 S = new (Context) AtomicExpr(Empty);
4528 break;
4529
4530 case EXPR_LAMBDA: {
4531 unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
4532 S = LambdaExpr::CreateDeserialized(C: Context, NumCaptures);
4533 break;
4534 }
4535
4536 case STMT_COROUTINE_BODY: {
4537 unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
4538 S = CoroutineBodyStmt::Create(C: Context, Empty, NumParams);
4539 break;
4540 }
4541
4542 case STMT_CORETURN:
4543 S = new (Context) CoreturnStmt(Empty);
4544 break;
4545
4546 case EXPR_COAWAIT:
4547 S = new (Context) CoawaitExpr(Empty);
4548 break;
4549
4550 case EXPR_COYIELD:
4551 S = new (Context) CoyieldExpr(Empty);
4552 break;
4553
4554 case EXPR_DEPENDENT_COAWAIT:
4555 S = new (Context) DependentCoawaitExpr(Empty);
4556 break;
4557
4558 case EXPR_CONCEPT_SPECIALIZATION: {
4559 S = new (Context) ConceptSpecializationExpr(Empty);
4560 break;
4561 }
4562
4563 case EXPR_CXX_EXPANSION_SELECT:
4564 S = new (Context) CXXExpansionSelectExpr(Empty);
4565 break;
4566
4567 case STMT_OPENACC_COMPUTE_CONSTRUCT: {
4568 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4569 S = OpenACCComputeConstruct::CreateEmpty(C: Context, NumClauses);
4570 break;
4571 }
4572 case STMT_OPENACC_LOOP_CONSTRUCT: {
4573 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4574 S = OpenACCLoopConstruct::CreateEmpty(C: Context, NumClauses);
4575 break;
4576 }
4577 case STMT_OPENACC_COMBINED_CONSTRUCT: {
4578 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4579 S = OpenACCCombinedConstruct::CreateEmpty(C: Context, NumClauses);
4580 break;
4581 }
4582 case STMT_OPENACC_DATA_CONSTRUCT: {
4583 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4584 S = OpenACCDataConstruct::CreateEmpty(C: Context, NumClauses);
4585 break;
4586 }
4587 case STMT_OPENACC_ENTER_DATA_CONSTRUCT: {
4588 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4589 S = OpenACCEnterDataConstruct::CreateEmpty(C: Context, NumClauses);
4590 break;
4591 }
4592 case STMT_OPENACC_EXIT_DATA_CONSTRUCT: {
4593 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4594 S = OpenACCExitDataConstruct::CreateEmpty(C: Context, NumClauses);
4595 break;
4596 }
4597 case STMT_OPENACC_HOST_DATA_CONSTRUCT: {
4598 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4599 S = OpenACCHostDataConstruct::CreateEmpty(C: Context, NumClauses);
4600 break;
4601 }
4602 case STMT_OPENACC_WAIT_CONSTRUCT: {
4603 unsigned NumExprs = Record[ASTStmtReader::NumStmtFields];
4604 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4605 S = OpenACCWaitConstruct::CreateEmpty(C: Context, NumExprs, NumClauses);
4606 break;
4607 }
4608 case STMT_OPENACC_CACHE_CONSTRUCT: {
4609 unsigned NumVars = Record[ASTStmtReader::NumStmtFields];
4610 S = OpenACCCacheConstruct::CreateEmpty(C: Context, NumVars);
4611 break;
4612 }
4613 case STMT_OPENACC_INIT_CONSTRUCT: {
4614 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4615 S = OpenACCInitConstruct::CreateEmpty(C: Context, NumClauses);
4616 break;
4617 }
4618 case STMT_OPENACC_SHUTDOWN_CONSTRUCT: {
4619 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4620 S = OpenACCShutdownConstruct::CreateEmpty(C: Context, NumClauses);
4621 break;
4622 }
4623 case STMT_OPENACC_SET_CONSTRUCT: {
4624 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4625 S = OpenACCSetConstruct::CreateEmpty(C: Context, NumClauses);
4626 break;
4627 }
4628 case STMT_OPENACC_UPDATE_CONSTRUCT: {
4629 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4630 S = OpenACCUpdateConstruct::CreateEmpty(C: Context, NumClauses);
4631 break;
4632 }
4633 case STMT_OPENACC_ATOMIC_CONSTRUCT: {
4634 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4635 S = OpenACCAtomicConstruct::CreateEmpty(C: Context, NumClauses);
4636 break;
4637 }
4638 case EXPR_REQUIRES: {
4639 unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields];
4640 unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1];
4641 S = RequiresExpr::Create(C&: Context, Empty, NumLocalParameters: numLocalParameters,
4642 NumRequirements: numRequirement);
4643 break;
4644 }
4645 case EXPR_HLSL_OUT_ARG:
4646 S = HLSLOutArgExpr::CreateEmpty(Ctx: Context);
4647 break;
4648 case EXPR_REFLECT: {
4649 S = CXXReflectExpr::CreateEmpty(C&: Context);
4650 break;
4651 }
4652 }
4653
4654 // We hit a STMT_STOP, so we're done with this expression.
4655 if (Finished)
4656 break;
4657
4658 ++NumStatementsRead;
4659
4660 if (S && !IsStmtReference) {
4661 Reader.Visit(S);
4662 StmtEntries[Cursor.GetCurrentBitNo()] = S;
4663 }
4664
4665 assert(Record.getIdx() == Record.size() &&
4666 "Invalid deserialization of statement");
4667 StmtStack.push_back(Elt: S);
4668 }
4669Done:
4670 assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
4671 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
4672 return StmtStack.pop_back_val();
4673}
4674