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