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