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 NumClauses field was read in ReadStmtFromStream.
2545 Record.skipInts(N: 1);
2546 VisitOMPExecutableDirective(E: D);
2547}
2548
2549void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2550 VisitStmt(S: D);
2551 VisitOMPExecutableDirective(E: D);
2552 D->setHasCancel(Record.readBool());
2553}
2554
2555void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2556 VisitOMPLoopDirective(D);
2557}
2558
2559void ASTStmtReader::VisitOMPCanonicalLoopNestTransformationDirective(
2560 OMPCanonicalLoopNestTransformationDirective *D) {
2561 VisitOMPLoopBasedDirective(D);
2562 D->setNumGeneratedTopLevelLoops(Record.readUInt32());
2563}
2564
2565void ASTStmtReader::VisitOMPTileDirective(OMPTileDirective *D) {
2566 VisitOMPCanonicalLoopNestTransformationDirective(D);
2567}
2568
2569void ASTStmtReader::VisitOMPStripeDirective(OMPStripeDirective *D) {
2570 VisitOMPCanonicalLoopNestTransformationDirective(D);
2571}
2572
2573void ASTStmtReader::VisitOMPUnrollDirective(OMPUnrollDirective *D) {
2574 VisitOMPCanonicalLoopNestTransformationDirective(D);
2575}
2576
2577void ASTStmtReader::VisitOMPReverseDirective(OMPReverseDirective *D) {
2578 VisitOMPCanonicalLoopNestTransformationDirective(D);
2579}
2580
2581void ASTStmtReader::VisitOMPCanonicalLoopSequenceTransformationDirective(
2582 OMPCanonicalLoopSequenceTransformationDirective *D) {
2583 VisitStmt(S: D);
2584 VisitOMPExecutableDirective(E: D);
2585 D->setNumGeneratedTopLevelLoops(Record.readUInt32());
2586}
2587
2588void ASTStmtReader::VisitOMPInterchangeDirective(OMPInterchangeDirective *D) {
2589 VisitOMPCanonicalLoopNestTransformationDirective(D);
2590}
2591
2592void ASTStmtReader::VisitOMPFlattenDirective(OMPFlattenDirective *D) {
2593 VisitOMPCanonicalLoopNestTransformationDirective(D);
2594}
2595
2596void ASTStmtReader::VisitOMPSplitDirective(OMPSplitDirective *D) {
2597 VisitOMPCanonicalLoopNestTransformationDirective(D);
2598}
2599
2600void ASTStmtReader::VisitOMPFuseDirective(OMPFuseDirective *D) {
2601 VisitOMPCanonicalLoopSequenceTransformationDirective(D);
2602}
2603
2604void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2605 VisitOMPLoopDirective(D);
2606 D->setHasCancel(Record.readBool());
2607}
2608
2609void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2610 VisitOMPLoopDirective(D);
2611}
2612
2613void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2614 VisitStmt(S: D);
2615 VisitOMPExecutableDirective(E: D);
2616 D->setHasCancel(Record.readBool());
2617}
2618
2619void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2620 VisitStmt(S: D);
2621 VisitOMPExecutableDirective(E: D);
2622 D->setHasCancel(Record.readBool());
2623}
2624
2625void ASTStmtReader::VisitOMPScopeDirective(OMPScopeDirective *D) {
2626 VisitStmt(S: D);
2627 VisitOMPExecutableDirective(E: D);
2628}
2629
2630void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2631 VisitStmt(S: D);
2632 VisitOMPExecutableDirective(E: D);
2633}
2634
2635void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2636 VisitStmt(S: D);
2637 VisitOMPExecutableDirective(E: D);
2638}
2639
2640void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2641 VisitStmt(S: D);
2642 VisitOMPExecutableDirective(E: D);
2643 D->DirName = Record.readDeclarationNameInfo();
2644}
2645
2646void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2647 VisitOMPLoopDirective(D);
2648 D->setHasCancel(Record.readBool());
2649}
2650
2651void ASTStmtReader::VisitOMPParallelForSimdDirective(
2652 OMPParallelForSimdDirective *D) {
2653 VisitOMPLoopDirective(D);
2654}
2655
2656void ASTStmtReader::VisitOMPParallelMasterDirective(
2657 OMPParallelMasterDirective *D) {
2658 VisitStmt(S: D);
2659 VisitOMPExecutableDirective(E: D);
2660}
2661
2662void ASTStmtReader::VisitOMPParallelMaskedDirective(
2663 OMPParallelMaskedDirective *D) {
2664 VisitStmt(S: D);
2665 VisitOMPExecutableDirective(E: D);
2666}
2667
2668void ASTStmtReader::VisitOMPParallelSectionsDirective(
2669 OMPParallelSectionsDirective *D) {
2670 VisitStmt(S: D);
2671 VisitOMPExecutableDirective(E: D);
2672 D->setHasCancel(Record.readBool());
2673}
2674
2675void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2676 VisitStmt(S: D);
2677 VisitOMPExecutableDirective(E: D);
2678 D->setHasCancel(Record.readBool());
2679}
2680
2681void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2682 VisitStmt(S: D);
2683 VisitOMPExecutableDirective(E: D);
2684}
2685
2686void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2687 VisitStmt(S: D);
2688 VisitOMPExecutableDirective(E: D);
2689}
2690
2691void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2692 VisitStmt(S: D);
2693 // The NumClauses field was read in ReadStmtFromStream.
2694 Record.skipInts(N: 1);
2695 VisitOMPExecutableDirective(E: D);
2696}
2697
2698void ASTStmtReader::VisitOMPAssumeDirective(OMPAssumeDirective *D) {
2699 VisitStmt(S: D);
2700 VisitOMPExecutableDirective(E: D);
2701}
2702
2703void ASTStmtReader::VisitOMPErrorDirective(OMPErrorDirective *D) {
2704 VisitStmt(S: D);
2705 // The NumClauses field was read in ReadStmtFromStream.
2706 Record.skipInts(N: 1);
2707 VisitOMPExecutableDirective(E: D);
2708}
2709
2710void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2711 VisitStmt(S: D);
2712 VisitOMPExecutableDirective(E: D);
2713}
2714
2715void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2716 VisitStmt(S: D);
2717 VisitOMPExecutableDirective(E: D);
2718}
2719
2720void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2721 VisitStmt(S: D);
2722 VisitOMPExecutableDirective(E: D);
2723}
2724
2725void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) {
2726 VisitStmt(S: D);
2727 VisitOMPExecutableDirective(E: D);
2728}
2729
2730void ASTStmtReader::VisitOMPOrderedStandaloneDirective(
2731 OMPOrderedStandaloneDirective *D) {
2732 VisitStmt(S: D);
2733 VisitOMPExecutableDirective(E: D);
2734}
2735
2736void ASTStmtReader::VisitOMPOrderedBlockAssocDirective(
2737 OMPOrderedBlockAssocDirective *D) {
2738 VisitStmt(S: D);
2739 VisitOMPExecutableDirective(E: D);
2740}
2741
2742void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2743 VisitStmt(S: D);
2744 VisitOMPExecutableDirective(E: D);
2745 D->Flags.IsXLHSInRHSPart = Record.readBool() ? 1 : 0;
2746 D->Flags.IsPostfixUpdate = Record.readBool() ? 1 : 0;
2747 D->Flags.IsFailOnly = Record.readBool() ? 1 : 0;
2748}
2749
2750void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2751 VisitStmt(S: D);
2752 VisitOMPExecutableDirective(E: D);
2753}
2754
2755void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2756 VisitStmt(S: D);
2757 VisitOMPExecutableDirective(E: D);
2758}
2759
2760void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2761 OMPTargetEnterDataDirective *D) {
2762 VisitStmt(S: D);
2763 VisitOMPExecutableDirective(E: D);
2764}
2765
2766void ASTStmtReader::VisitOMPTargetExitDataDirective(
2767 OMPTargetExitDataDirective *D) {
2768 VisitStmt(S: D);
2769 VisitOMPExecutableDirective(E: D);
2770}
2771
2772void ASTStmtReader::VisitOMPTargetParallelDirective(
2773 OMPTargetParallelDirective *D) {
2774 VisitStmt(S: D);
2775 VisitOMPExecutableDirective(E: D);
2776 D->setHasCancel(Record.readBool());
2777}
2778
2779void ASTStmtReader::VisitOMPTargetParallelForDirective(
2780 OMPTargetParallelForDirective *D) {
2781 VisitOMPLoopDirective(D);
2782 D->setHasCancel(Record.readBool());
2783}
2784
2785void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2786 VisitStmt(S: D);
2787 VisitOMPExecutableDirective(E: D);
2788}
2789
2790void ASTStmtReader::VisitOMPCancellationPointDirective(
2791 OMPCancellationPointDirective *D) {
2792 VisitStmt(S: D);
2793 VisitOMPExecutableDirective(E: D);
2794 D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2795}
2796
2797void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2798 VisitStmt(S: D);
2799 VisitOMPExecutableDirective(E: D);
2800 D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2801}
2802
2803void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2804 VisitOMPLoopDirective(D);
2805 D->setHasCancel(Record.readBool());
2806}
2807
2808void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2809 VisitOMPLoopDirective(D);
2810}
2811
2812void ASTStmtReader::VisitOMPMasterTaskLoopDirective(
2813 OMPMasterTaskLoopDirective *D) {
2814 VisitOMPLoopDirective(D);
2815 D->setHasCancel(Record.readBool());
2816}
2817
2818void ASTStmtReader::VisitOMPMaskedTaskLoopDirective(
2819 OMPMaskedTaskLoopDirective *D) {
2820 VisitOMPLoopDirective(D);
2821 D->setHasCancel(Record.readBool());
2822}
2823
2824void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective(
2825 OMPMasterTaskLoopSimdDirective *D) {
2826 VisitOMPLoopDirective(D);
2827}
2828
2829void ASTStmtReader::VisitOMPMaskedTaskLoopSimdDirective(
2830 OMPMaskedTaskLoopSimdDirective *D) {
2831 VisitOMPLoopDirective(D);
2832}
2833
2834void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective(
2835 OMPParallelMasterTaskLoopDirective *D) {
2836 VisitOMPLoopDirective(D);
2837 D->setHasCancel(Record.readBool());
2838}
2839
2840void ASTStmtReader::VisitOMPParallelMaskedTaskLoopDirective(
2841 OMPParallelMaskedTaskLoopDirective *D) {
2842 VisitOMPLoopDirective(D);
2843 D->setHasCancel(Record.readBool());
2844}
2845
2846void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective(
2847 OMPParallelMasterTaskLoopSimdDirective *D) {
2848 VisitOMPLoopDirective(D);
2849}
2850
2851void ASTStmtReader::VisitOMPParallelMaskedTaskLoopSimdDirective(
2852 OMPParallelMaskedTaskLoopSimdDirective *D) {
2853 VisitOMPLoopDirective(D);
2854}
2855
2856void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2857 VisitOMPLoopDirective(D);
2858}
2859
2860void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2861 VisitStmt(S: D);
2862 VisitOMPExecutableDirective(E: D);
2863}
2864
2865void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2866 OMPDistributeParallelForDirective *D) {
2867 VisitOMPLoopDirective(D);
2868 D->setHasCancel(Record.readBool());
2869}
2870
2871void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2872 OMPDistributeParallelForSimdDirective *D) {
2873 VisitOMPLoopDirective(D);
2874}
2875
2876void ASTStmtReader::VisitOMPDistributeSimdDirective(
2877 OMPDistributeSimdDirective *D) {
2878 VisitOMPLoopDirective(D);
2879}
2880
2881void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2882 OMPTargetParallelForSimdDirective *D) {
2883 VisitOMPLoopDirective(D);
2884}
2885
2886void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2887 VisitOMPLoopDirective(D);
2888}
2889
2890void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2891 OMPTeamsDistributeDirective *D) {
2892 VisitOMPLoopDirective(D);
2893}
2894
2895void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2896 OMPTeamsDistributeSimdDirective *D) {
2897 VisitOMPLoopDirective(D);
2898}
2899
2900void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2901 OMPTeamsDistributeParallelForSimdDirective *D) {
2902 VisitOMPLoopDirective(D);
2903}
2904
2905void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2906 OMPTeamsDistributeParallelForDirective *D) {
2907 VisitOMPLoopDirective(D);
2908 D->setHasCancel(Record.readBool());
2909}
2910
2911void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2912 VisitStmt(S: D);
2913 VisitOMPExecutableDirective(E: D);
2914}
2915
2916void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2917 OMPTargetTeamsDistributeDirective *D) {
2918 VisitOMPLoopDirective(D);
2919}
2920
2921void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2922 OMPTargetTeamsDistributeParallelForDirective *D) {
2923 VisitOMPLoopDirective(D);
2924 D->setHasCancel(Record.readBool());
2925}
2926
2927void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2928 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2929 VisitOMPLoopDirective(D);
2930}
2931
2932void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2933 OMPTargetTeamsDistributeSimdDirective *D) {
2934 VisitOMPLoopDirective(D);
2935}
2936
2937void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) {
2938 VisitStmt(S: D);
2939 VisitOMPExecutableDirective(E: D);
2940}
2941
2942void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
2943 VisitStmt(S: D);
2944 VisitOMPExecutableDirective(E: D);
2945 D->setTargetCallLoc(Record.readSourceLocation());
2946}
2947
2948void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
2949 VisitStmt(S: D);
2950 VisitOMPExecutableDirective(E: D);
2951}
2952
2953void ASTStmtReader::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) {
2954 VisitOMPLoopDirective(D);
2955}
2956
2957void ASTStmtReader::VisitOMPTeamsGenericLoopDirective(
2958 OMPTeamsGenericLoopDirective *D) {
2959 VisitOMPLoopDirective(D);
2960}
2961
2962void ASTStmtReader::VisitOMPTargetTeamsGenericLoopDirective(
2963 OMPTargetTeamsGenericLoopDirective *D) {
2964 VisitOMPLoopDirective(D);
2965 D->setCanBeParallelFor(Record.readBool());
2966}
2967
2968void ASTStmtReader::VisitOMPParallelGenericLoopDirective(
2969 OMPParallelGenericLoopDirective *D) {
2970 VisitOMPLoopDirective(D);
2971}
2972
2973void ASTStmtReader::VisitOMPTargetParallelGenericLoopDirective(
2974 OMPTargetParallelGenericLoopDirective *D) {
2975 VisitOMPLoopDirective(D);
2976}
2977
2978//===----------------------------------------------------------------------===//
2979// OpenACC Constructs/Directives.
2980//===----------------------------------------------------------------------===//
2981void ASTStmtReader::VisitOpenACCConstructStmt(OpenACCConstructStmt *S) {
2982 (void)Record.readInt();
2983 S->Kind = Record.readEnum<OpenACCDirectiveKind>();
2984 S->Range = Record.readSourceRange();
2985 S->DirectiveLoc = Record.readSourceLocation();
2986 Record.readOpenACCClauseList(Clauses: S->Clauses);
2987}
2988
2989void ASTStmtReader::VisitOpenACCAssociatedStmtConstruct(
2990 OpenACCAssociatedStmtConstruct *S) {
2991 VisitOpenACCConstructStmt(S);
2992 S->setAssociatedStmt(Record.readSubStmt());
2993}
2994
2995void ASTStmtReader::VisitOpenACCComputeConstruct(OpenACCComputeConstruct *S) {
2996 VisitStmt(S);
2997 VisitOpenACCAssociatedStmtConstruct(S);
2998}
2999
3000void ASTStmtReader::VisitOpenACCLoopConstruct(OpenACCLoopConstruct *S) {
3001 VisitStmt(S);
3002 VisitOpenACCAssociatedStmtConstruct(S);
3003 S->ParentComputeConstructKind = Record.readEnum<OpenACCDirectiveKind>();
3004}
3005
3006void ASTStmtReader::VisitOpenACCCombinedConstruct(OpenACCCombinedConstruct *S) {
3007 VisitStmt(S);
3008 VisitOpenACCAssociatedStmtConstruct(S);
3009}
3010
3011void ASTStmtReader::VisitOpenACCDataConstruct(OpenACCDataConstruct *S) {
3012 VisitStmt(S);
3013 VisitOpenACCAssociatedStmtConstruct(S);
3014}
3015
3016void ASTStmtReader::VisitOpenACCEnterDataConstruct(
3017 OpenACCEnterDataConstruct *S) {
3018 VisitStmt(S);
3019 VisitOpenACCConstructStmt(S);
3020}
3021
3022void ASTStmtReader::VisitOpenACCExitDataConstruct(OpenACCExitDataConstruct *S) {
3023 VisitStmt(S);
3024 VisitOpenACCConstructStmt(S);
3025}
3026
3027void ASTStmtReader::VisitOpenACCInitConstruct(OpenACCInitConstruct *S) {
3028 VisitStmt(S);
3029 VisitOpenACCConstructStmt(S);
3030}
3031
3032void ASTStmtReader::VisitOpenACCShutdownConstruct(OpenACCShutdownConstruct *S) {
3033 VisitStmt(S);
3034 VisitOpenACCConstructStmt(S);
3035}
3036
3037void ASTStmtReader::VisitOpenACCSetConstruct(OpenACCSetConstruct *S) {
3038 VisitStmt(S);
3039 VisitOpenACCConstructStmt(S);
3040}
3041
3042void ASTStmtReader::VisitOpenACCUpdateConstruct(OpenACCUpdateConstruct *S) {
3043 VisitStmt(S);
3044 VisitOpenACCConstructStmt(S);
3045}
3046
3047void ASTStmtReader::VisitOpenACCHostDataConstruct(OpenACCHostDataConstruct *S) {
3048 VisitStmt(S);
3049 VisitOpenACCAssociatedStmtConstruct(S);
3050}
3051
3052void ASTStmtReader::VisitOpenACCWaitConstruct(OpenACCWaitConstruct *S) {
3053 VisitStmt(S);
3054 // Consume the count of Expressions.
3055 (void)Record.readInt();
3056 VisitOpenACCConstructStmt(S);
3057 S->LParenLoc = Record.readSourceLocation();
3058 S->RParenLoc = Record.readSourceLocation();
3059 S->QueuesLoc = Record.readSourceLocation();
3060
3061 for (unsigned I = 0; I < S->NumExprs; ++I) {
3062 S->getExprPtr()[I] = cast_if_present<Expr>(Val: Record.readSubStmt());
3063 assert((I == 0 || S->getExprPtr()[I] != nullptr) &&
3064 "Only first expression should be null");
3065 }
3066}
3067
3068void ASTStmtReader::VisitOpenACCCacheConstruct(OpenACCCacheConstruct *S) {
3069 VisitStmt(S);
3070 (void)Record.readInt();
3071 VisitOpenACCConstructStmt(S);
3072 S->ParensLoc = Record.readSourceRange();
3073 S->ReadOnlyLoc = Record.readSourceLocation();
3074 for (unsigned I = 0; I < S->NumVars; ++I)
3075 S->getVarList()[I] = cast<Expr>(Val: Record.readSubStmt());
3076}
3077
3078void ASTStmtReader::VisitOpenACCAtomicConstruct(OpenACCAtomicConstruct *S) {
3079 VisitStmt(S);
3080 VisitOpenACCConstructStmt(S);
3081 S->AtomicKind = Record.readEnum<OpenACCAtomicKind>();
3082 S->setAssociatedStmt(Record.readSubStmt());
3083}
3084
3085//===----------------------------------------------------------------------===//
3086// HLSL Constructs/Directives.
3087//===----------------------------------------------------------------------===//
3088
3089void ASTStmtReader::VisitHLSLOutArgExpr(HLSLOutArgExpr *S) {
3090 VisitExpr(E: S);
3091 S->SubExprs[HLSLOutArgExpr::BaseLValue] = Record.readSubExpr();
3092 S->SubExprs[HLSLOutArgExpr::CastedTemporary] = Record.readSubExpr();
3093 S->SubExprs[HLSLOutArgExpr::WritebackCast] = Record.readSubExpr();
3094 S->IsInOut = Record.readBool();
3095}
3096
3097//===----------------------------------------------------------------------===//
3098// ASTReader Implementation
3099//===----------------------------------------------------------------------===//
3100
3101Stmt *ASTReader::ReadStmt(ModuleFile &F) {
3102 switch (ReadingKind) {
3103 case Read_None:
3104 llvm_unreachable("should not call this when not reading anything");
3105 case Read_Decl:
3106 case Read_Type:
3107 return ReadStmtFromStream(F);
3108 case Read_Stmt:
3109 return ReadSubStmt();
3110 }
3111
3112 llvm_unreachable("ReadingKind not set ?");
3113}
3114
3115Expr *ASTReader::ReadExpr(ModuleFile &F) {
3116 return cast_or_null<Expr>(Val: ReadStmt(F));
3117}
3118
3119Expr *ASTReader::ReadSubExpr() {
3120 return cast_or_null<Expr>(Val: ReadSubStmt());
3121}
3122
3123// Within the bitstream, expressions are stored in Reverse Polish
3124// Notation, with each of the subexpressions preceding the
3125// expression they are stored in. Subexpressions are stored from last to first.
3126// To evaluate expressions, we continue reading expressions and placing them on
3127// the stack, with expressions having operands removing those operands from the
3128// stack. Evaluation terminates when we see a STMT_STOP record, and
3129// the single remaining expression on the stack is our result.
3130Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
3131 ReadingKindTracker ReadingKind(Read_Stmt, *this);
3132 llvm::BitstreamCursor &Cursor = F.DeclsCursor;
3133
3134 // Map of offset to previously deserialized stmt. The offset points
3135 // just after the stmt record.
3136 llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
3137
3138#ifndef NDEBUG
3139 unsigned PrevNumStmts = StmtStack.size();
3140#endif
3141
3142 ASTRecordReader Record(*this, F);
3143 ASTStmtReader Reader(Record, Cursor);
3144 Stmt::EmptyShell Empty;
3145
3146 while (true) {
3147 llvm::Expected<llvm::BitstreamEntry> MaybeEntry =
3148 Cursor.advanceSkippingSubblocks();
3149 if (!MaybeEntry) {
3150 Error(Msg: toString(E: MaybeEntry.takeError()));
3151 return nullptr;
3152 }
3153 llvm::BitstreamEntry Entry = MaybeEntry.get();
3154
3155 switch (Entry.Kind) {
3156 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
3157 case llvm::BitstreamEntry::Error:
3158 Error(Msg: "malformed block record in AST file");
3159 return nullptr;
3160 case llvm::BitstreamEntry::EndBlock:
3161 goto Done;
3162 case llvm::BitstreamEntry::Record:
3163 // The interesting case.
3164 break;
3165 }
3166
3167 ASTContext &Context = getContext();
3168 Stmt *S = nullptr;
3169 bool Finished = false;
3170 bool IsStmtReference = false;
3171 Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, AbbrevID: Entry.ID);
3172 if (!MaybeStmtCode) {
3173 Error(Msg: toString(E: MaybeStmtCode.takeError()));
3174 return nullptr;
3175 }
3176 switch ((StmtCode)MaybeStmtCode.get()) {
3177 case STMT_STOP:
3178 Finished = true;
3179 break;
3180
3181 case STMT_REF_PTR:
3182 IsStmtReference = true;
3183 assert(StmtEntries.contains(Record[0]) &&
3184 "No stmt was recorded for this offset reference!");
3185 S = StmtEntries[Record.readInt()];
3186 break;
3187
3188 case STMT_NULL_PTR:
3189 S = nullptr;
3190 break;
3191
3192 case STMT_NULL:
3193 S = new (Context) NullStmt(Empty);
3194 break;
3195
3196 case STMT_COMPOUND: {
3197 unsigned NumStmts = Record[ASTStmtReader::NumStmtFields];
3198 bool HasFPFeatures = Record[ASTStmtReader::NumStmtFields + 1];
3199 S = CompoundStmt::CreateEmpty(C: Context, NumStmts, HasFPFeatures);
3200 break;
3201 }
3202
3203 case STMT_CASE:
3204 S = CaseStmt::CreateEmpty(
3205 Ctx: Context,
3206 /*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]);
3207 break;
3208
3209 case STMT_DEFAULT:
3210 S = new (Context) DefaultStmt(Empty);
3211 break;
3212
3213 case STMT_LABEL:
3214 S = new (Context) LabelStmt(Empty);
3215 break;
3216
3217 case STMT_ATTRIBUTED:
3218 S = AttributedStmt::CreateEmpty(
3219 C: Context,
3220 /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
3221 break;
3222
3223 case STMT_IF: {
3224 BitsUnpacker IfStmtBits(Record[ASTStmtReader::NumStmtFields]);
3225 bool HasElse = IfStmtBits.getNextBit();
3226 bool HasVar = IfStmtBits.getNextBit();
3227 bool HasInit = IfStmtBits.getNextBit();
3228 S = IfStmt::CreateEmpty(Ctx: Context, HasElse, HasVar, HasInit);
3229 break;
3230 }
3231
3232 case STMT_SWITCH:
3233 S = SwitchStmt::CreateEmpty(
3234 Ctx: Context,
3235 /* HasInit=*/Record[ASTStmtReader::NumStmtFields],
3236 /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]);
3237 break;
3238
3239 case STMT_WHILE:
3240 S = WhileStmt::CreateEmpty(
3241 Ctx: Context,
3242 /* HasVar=*/Record[ASTStmtReader::NumStmtFields]);
3243 break;
3244
3245 case STMT_DO:
3246 S = new (Context) DoStmt(Empty);
3247 break;
3248
3249 case STMT_FOR:
3250 S = new (Context) ForStmt(Empty);
3251 break;
3252
3253 case STMT_GOTO:
3254 S = new (Context) GotoStmt(Empty);
3255 break;
3256
3257 case STMT_INDIRECT_GOTO:
3258 S = new (Context) IndirectGotoStmt(Empty);
3259 break;
3260
3261 case STMT_CONTINUE:
3262 S = new (Context) ContinueStmt(Empty);
3263 break;
3264
3265 case STMT_BREAK:
3266 S = new (Context) BreakStmt(Empty);
3267 break;
3268
3269 case STMT_DEFER:
3270 S = DeferStmt::CreateEmpty(Context, Empty);
3271 break;
3272
3273 case STMT_RETURN:
3274 S = ReturnStmt::CreateEmpty(
3275 Ctx: Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]);
3276 break;
3277
3278 case STMT_DECL:
3279 S = new (Context) DeclStmt(Empty);
3280 break;
3281
3282 case STMT_GCCASM:
3283 S = new (Context) GCCAsmStmt(Empty);
3284 break;
3285
3286 case STMT_MSASM:
3287 S = new (Context) MSAsmStmt(Empty);
3288 break;
3289
3290 case STMT_CAPTURED:
3291 S = CapturedStmt::CreateDeserialized(
3292 Context, NumCaptures: Record[ASTStmtReader::NumStmtFields]);
3293 break;
3294
3295 case STMT_SYCLKERNELCALL:
3296 S = new (Context) SYCLKernelCallStmt(Empty);
3297 break;
3298
3299 case EXPR_CONSTANT:
3300 S = ConstantExpr::CreateEmpty(
3301 Context, StorageKind: static_cast<ConstantResultStorageKind>(
3302 /*StorageKind=*/Record[ASTStmtReader::NumExprFields]));
3303 break;
3304
3305 case EXPR_SYCL_UNIQUE_STABLE_NAME:
3306 S = SYCLUniqueStableNameExpr::CreateEmpty(Ctx: Context);
3307 break;
3308
3309 case STMT_UNRESOLVED_SYCL_KERNEL_CALL:
3310 S = UnresolvedSYCLKernelCallStmt::CreateEmpty(C: Context);
3311 break;
3312
3313 case EXPR_OPENACC_ASTERISK_SIZE:
3314 S = OpenACCAsteriskSizeExpr::CreateEmpty(C: Context);
3315 break;
3316
3317 case EXPR_PREDEFINED:
3318 S = PredefinedExpr::CreateEmpty(
3319 Ctx: Context,
3320 /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]);
3321 break;
3322
3323 case EXPR_DECL_REF: {
3324 BitsUnpacker DeclRefExprBits(Record[ASTStmtReader::NumExprFields]);
3325 DeclRefExprBits.advance(BitsWidth: 5);
3326 bool HasFoundDecl = DeclRefExprBits.getNextBit();
3327 bool HasQualifier = DeclRefExprBits.getNextBit();
3328 bool HasTemplateKWAndArgsInfo = DeclRefExprBits.getNextBit();
3329 unsigned NumTemplateArgs = HasTemplateKWAndArgsInfo
3330 ? Record[ASTStmtReader::NumExprFields + 1]
3331 : 0;
3332 S = DeclRefExpr::CreateEmpty(Context, HasQualifier, HasFoundDecl,
3333 HasTemplateKWAndArgsInfo, NumTemplateArgs);
3334 break;
3335 }
3336
3337 case EXPR_INTEGER_LITERAL:
3338 S = IntegerLiteral::Create(C: Context, Empty);
3339 break;
3340
3341 case EXPR_FIXEDPOINT_LITERAL:
3342 S = FixedPointLiteral::Create(C: Context, Empty);
3343 break;
3344
3345 case EXPR_FLOATING_LITERAL:
3346 S = FloatingLiteral::Create(C: Context, Empty);
3347 break;
3348
3349 case EXPR_IMAGINARY_LITERAL:
3350 S = new (Context) ImaginaryLiteral(Empty);
3351 break;
3352
3353 case EXPR_STRING_LITERAL:
3354 S = StringLiteral::CreateEmpty(
3355 Ctx: Context,
3356 /* NumConcatenated=*/Record[ASTStmtReader::NumExprFields],
3357 /* Length=*/Record[ASTStmtReader::NumExprFields + 1],
3358 /* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]);
3359 break;
3360
3361 case EXPR_CHARACTER_LITERAL:
3362 S = new (Context) CharacterLiteral(Empty);
3363 break;
3364
3365 case EXPR_PAREN:
3366 S = new (Context) ParenExpr(Empty);
3367 break;
3368
3369 case EXPR_PAREN_LIST:
3370 S = ParenListExpr::CreateEmpty(
3371 Ctx: Context,
3372 /* NumExprs=*/Record[ASTStmtReader::NumExprFields]);
3373 break;
3374
3375 case EXPR_UNARY_OPERATOR: {
3376 BitsUnpacker UnaryOperatorBits(Record[ASTStmtReader::NumStmtFields]);
3377 UnaryOperatorBits.advance(BitsWidth: ASTStmtReader::NumExprBits);
3378 bool HasFPFeatures = UnaryOperatorBits.getNextBit();
3379 S = UnaryOperator::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3380 break;
3381 }
3382
3383 case EXPR_OFFSETOF:
3384 S = OffsetOfExpr::CreateEmpty(C: Context,
3385 NumComps: Record[ASTStmtReader::NumExprFields],
3386 NumExprs: Record[ASTStmtReader::NumExprFields + 1]);
3387 break;
3388
3389 case EXPR_SIZEOF_ALIGN_OF:
3390 S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
3391 break;
3392
3393 case EXPR_ARRAY_SUBSCRIPT:
3394 S = new (Context) ArraySubscriptExpr(Empty);
3395 break;
3396
3397 case EXPR_MATRIX_SUBSCRIPT:
3398 S = new (Context) MatrixSubscriptExpr(Empty);
3399 break;
3400
3401 case EXPR_ARRAY_SECTION:
3402 S = new (Context) ArraySectionExpr(Empty);
3403 break;
3404
3405 case EXPR_OMP_ARRAY_SHAPING:
3406 S = OMPArrayShapingExpr::CreateEmpty(
3407 Context, NumDims: Record[ASTStmtReader::NumExprFields]);
3408 break;
3409
3410 case EXPR_OMP_ITERATOR:
3411 S = OMPIteratorExpr::CreateEmpty(Context,
3412 NumIterators: Record[ASTStmtReader::NumExprFields]);
3413 break;
3414
3415 case EXPR_CALL: {
3416 auto NumArgs = Record[ASTStmtReader::NumExprFields];
3417 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
3418 CallExprBits.advance(BitsWidth: 1);
3419 auto HasFPFeatures = CallExprBits.getNextBit();
3420 S = CallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures, Empty);
3421 break;
3422 }
3423
3424 case EXPR_RECOVERY:
3425 S = RecoveryExpr::CreateEmpty(
3426 Ctx&: Context, /*NumArgs=*/NumSubExprs: Record[ASTStmtReader::NumExprFields]);
3427 break;
3428
3429 case EXPR_MEMBER: {
3430 BitsUnpacker ExprMemberBits(Record[ASTStmtReader::NumExprFields]);
3431 bool HasQualifier = ExprMemberBits.getNextBit();
3432 bool HasFoundDecl = ExprMemberBits.getNextBit();
3433 bool HasTemplateInfo = ExprMemberBits.getNextBit();
3434 unsigned NumTemplateArgs = Record[ASTStmtReader::NumExprFields + 1];
3435 S = MemberExpr::CreateEmpty(Context, HasQualifier, HasFoundDecl,
3436 HasTemplateKWAndArgsInfo: HasTemplateInfo, NumTemplateArgs);
3437 break;
3438 }
3439
3440 case EXPR_BINARY_OPERATOR: {
3441 BitsUnpacker BinaryOperatorBits(Record[ASTStmtReader::NumExprFields]);
3442 BinaryOperatorBits.advance(/*Size of opcode*/ BitsWidth: 6);
3443 bool HasFPFeatures = BinaryOperatorBits.getNextBit();
3444 S = BinaryOperator::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3445 break;
3446 }
3447
3448 case EXPR_COMPOUND_ASSIGN_OPERATOR: {
3449 BitsUnpacker BinaryOperatorBits(Record[ASTStmtReader::NumExprFields]);
3450 BinaryOperatorBits.advance(/*Size of opcode*/ BitsWidth: 6);
3451 bool HasFPFeatures = BinaryOperatorBits.getNextBit();
3452 S = CompoundAssignOperator::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3453 break;
3454 }
3455
3456 case EXPR_CONDITIONAL_OPERATOR:
3457 S = new (Context) ConditionalOperator(Empty);
3458 break;
3459
3460 case EXPR_BINARY_CONDITIONAL_OPERATOR:
3461 S = new (Context) BinaryConditionalOperator(Empty);
3462 break;
3463
3464 case EXPR_IMPLICIT_CAST: {
3465 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
3466 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
3467 CastExprBits.advance(BitsWidth: 7);
3468 bool HasFPFeatures = CastExprBits.getNextBit();
3469 S = ImplicitCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures);
3470 break;
3471 }
3472
3473 case EXPR_CSTYLE_CAST: {
3474 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
3475 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
3476 CastExprBits.advance(BitsWidth: 7);
3477 bool HasFPFeatures = CastExprBits.getNextBit();
3478 S = CStyleCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures);
3479 break;
3480 }
3481
3482 case EXPR_COMPOUND_LITERAL:
3483 S = new (Context) CompoundLiteralExpr(Empty);
3484 break;
3485
3486 case EXPR_EXT_VECTOR_ELEMENT:
3487 S = new (Context) ExtVectorElementExpr(Empty);
3488 break;
3489
3490 case EXPR_MATRIX_ELEMENT:
3491 S = new (Context) MatrixElementExpr(Empty);
3492 break;
3493
3494 case EXPR_INIT_LIST:
3495 S = new (Context) InitListExpr(Empty);
3496 break;
3497
3498 case EXPR_DESIGNATED_INIT:
3499 S = DesignatedInitExpr::CreateEmpty(C: Context,
3500 NumIndexExprs: Record[ASTStmtReader::NumExprFields] - 1);
3501
3502 break;
3503
3504 case EXPR_DESIGNATED_INIT_UPDATE:
3505 S = new (Context) DesignatedInitUpdateExpr(Empty);
3506 break;
3507
3508 case EXPR_IMPLICIT_VALUE_INIT:
3509 S = new (Context) ImplicitValueInitExpr(Empty);
3510 break;
3511
3512 case EXPR_NO_INIT:
3513 S = new (Context) NoInitExpr(Empty);
3514 break;
3515
3516 case EXPR_ARRAY_INIT_LOOP:
3517 S = new (Context) ArrayInitLoopExpr(Empty);
3518 break;
3519
3520 case EXPR_ARRAY_INIT_INDEX:
3521 S = new (Context) ArrayInitIndexExpr(Empty);
3522 break;
3523
3524 case EXPR_VA_ARG:
3525 S = new (Context) VAArgExpr(Empty);
3526 break;
3527
3528 case EXPR_SOURCE_LOC:
3529 S = new (Context) SourceLocExpr(Empty);
3530 break;
3531
3532 case EXPR_BUILTIN_PP_EMBED:
3533 S = new (Context) EmbedExpr(Empty);
3534 break;
3535
3536 case EXPR_ADDR_LABEL:
3537 S = new (Context) AddrLabelExpr(Empty);
3538 break;
3539
3540 case EXPR_STMT:
3541 S = new (Context) StmtExpr(Empty);
3542 break;
3543
3544 case EXPR_CHOOSE:
3545 S = new (Context) ChooseExpr(Empty);
3546 break;
3547
3548 case EXPR_GNU_NULL:
3549 S = new (Context) GNUNullExpr(Empty);
3550 break;
3551
3552 case EXPR_SHUFFLE_VECTOR:
3553 S = new (Context) ShuffleVectorExpr(Empty);
3554 break;
3555
3556 case EXPR_CONVERT_VECTOR: {
3557 BitsUnpacker ConvertVectorExprBits(Record[ASTStmtReader::NumStmtFields]);
3558 ConvertVectorExprBits.advance(BitsWidth: ASTStmtReader::NumExprBits);
3559 bool HasFPFeatures = ConvertVectorExprBits.getNextBit();
3560 S = ConvertVectorExpr::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3561 break;
3562 }
3563
3564 case EXPR_BLOCK:
3565 S = new (Context) BlockExpr(Empty);
3566 break;
3567
3568 case EXPR_GENERIC_SELECTION:
3569 S = GenericSelectionExpr::CreateEmpty(
3570 Context,
3571 /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
3572 break;
3573
3574 case EXPR_OBJC_STRING_LITERAL:
3575 S = new (Context) ObjCStringLiteral(Empty);
3576 break;
3577
3578 case EXPR_OBJC_BOXED_EXPRESSION:
3579 S = new (Context) ObjCBoxedExpr(Empty);
3580 break;
3581
3582 case EXPR_OBJC_ARRAY_LITERAL:
3583 S = ObjCArrayLiteral::CreateEmpty(
3584 C: Context, NumElements: Record[ASTStmtReader::NumObjCObjectLiteralFields]);
3585 break;
3586
3587 case EXPR_OBJC_DICTIONARY_LITERAL:
3588 S = ObjCDictionaryLiteral::CreateEmpty(
3589 C: Context, NumElements: Record[ASTStmtReader::NumObjCObjectLiteralFields],
3590 HasPackExpansions: Record[ASTStmtReader::NumObjCObjectLiteralFields + 1]);
3591 break;
3592
3593 case EXPR_OBJC_ENCODE:
3594 S = new (Context) ObjCEncodeExpr(Empty);
3595 break;
3596
3597 case EXPR_OBJC_SELECTOR_EXPR:
3598 S = new (Context) ObjCSelectorExpr(Empty);
3599 break;
3600
3601 case EXPR_OBJC_PROTOCOL_EXPR:
3602 S = new (Context) ObjCProtocolExpr(Empty);
3603 break;
3604
3605 case EXPR_OBJC_IVAR_REF_EXPR:
3606 S = new (Context) ObjCIvarRefExpr(Empty);
3607 break;
3608
3609 case EXPR_OBJC_PROPERTY_REF_EXPR:
3610 S = new (Context) ObjCPropertyRefExpr(Empty);
3611 break;
3612
3613 case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
3614 S = new (Context) ObjCSubscriptRefExpr(Empty);
3615 break;
3616
3617 case EXPR_OBJC_KVC_REF_EXPR:
3618 llvm_unreachable("mismatching AST file");
3619
3620 case EXPR_OBJC_MESSAGE_EXPR:
3621 S = ObjCMessageExpr::CreateEmpty(Context,
3622 NumArgs: Record[ASTStmtReader::NumExprFields],
3623 NumStoredSelLocs: Record[ASTStmtReader::NumExprFields + 1]);
3624 break;
3625
3626 case EXPR_OBJC_ISA:
3627 S = new (Context) ObjCIsaExpr(Empty);
3628 break;
3629
3630 case EXPR_OBJC_INDIRECT_COPY_RESTORE:
3631 S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3632 break;
3633
3634 case EXPR_OBJC_BRIDGED_CAST:
3635 S = new (Context) ObjCBridgedCastExpr(Empty);
3636 break;
3637
3638 case STMT_OBJC_FOR_COLLECTION:
3639 S = new (Context) ObjCForCollectionStmt(Empty);
3640 break;
3641
3642 case STMT_OBJC_CATCH:
3643 S = new (Context) ObjCAtCatchStmt(Empty);
3644 break;
3645
3646 case STMT_OBJC_FINALLY:
3647 S = new (Context) ObjCAtFinallyStmt(Empty);
3648 break;
3649
3650 case STMT_OBJC_AT_TRY:
3651 S = ObjCAtTryStmt::CreateEmpty(Context,
3652 NumCatchStmts: Record[ASTStmtReader::NumStmtFields],
3653 HasFinally: Record[ASTStmtReader::NumStmtFields + 1]);
3654 break;
3655
3656 case STMT_OBJC_AT_SYNCHRONIZED:
3657 S = new (Context) ObjCAtSynchronizedStmt(Empty);
3658 break;
3659
3660 case STMT_OBJC_AT_THROW:
3661 S = new (Context) ObjCAtThrowStmt(Empty);
3662 break;
3663
3664 case STMT_OBJC_AUTORELEASE_POOL:
3665 S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3666 break;
3667
3668 case EXPR_OBJC_BOOL_LITERAL:
3669 S = new (Context) ObjCBoolLiteralExpr(Empty);
3670 break;
3671
3672 case EXPR_OBJC_AVAILABILITY_CHECK:
3673 S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3674 break;
3675
3676 case STMT_SEH_LEAVE:
3677 S = new (Context) SEHLeaveStmt(Empty);
3678 break;
3679
3680 case STMT_SEH_EXCEPT:
3681 S = new (Context) SEHExceptStmt(Empty);
3682 break;
3683
3684 case STMT_SEH_FINALLY:
3685 S = new (Context) SEHFinallyStmt(Empty);
3686 break;
3687
3688 case STMT_SEH_TRY:
3689 S = new (Context) SEHTryStmt(Empty);
3690 break;
3691
3692 case STMT_CXX_CATCH:
3693 S = new (Context) CXXCatchStmt(Empty);
3694 break;
3695
3696 case STMT_CXX_TRY:
3697 S = CXXTryStmt::Create(C: Context, Empty,
3698 /*numHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3699 break;
3700
3701 case STMT_CXX_EXPANSION_PATTERN:
3702 S = CXXExpansionStmtPattern::CreateEmpty(
3703 Context, Empty,
3704 Kind: static_cast<CXXExpansionStmtPattern::ExpansionStmtKind>(
3705 Record[ASTStmtReader::NumStmtFields]));
3706 break;
3707
3708 case STMT_CXX_EXPANSION_INSTANTIATION:
3709 S = CXXExpansionStmtInstantiation::CreateEmpty(
3710 C&: Context, Empty, NumInstantiations: Record[ASTStmtReader::NumStmtFields],
3711 NumPreambleStmts: Record[ASTStmtReader::NumStmtFields + 1]);
3712 break;
3713
3714 case STMT_CXX_FOR_RANGE:
3715 S = new (Context) CXXForRangeStmt(Empty);
3716 break;
3717
3718 case STMT_MS_DEPENDENT_EXISTS:
3719 S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3720 NestedNameSpecifierLoc(),
3721 DeclarationNameInfo(),
3722 nullptr);
3723 break;
3724
3725 case STMT_OMP_CANONICAL_LOOP:
3726 S = OMPCanonicalLoop::createEmpty(Ctx: Context);
3727 break;
3728
3729 case STMT_OMP_META_DIRECTIVE:
3730 S = OMPMetaDirective::CreateEmpty(
3731 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3732 break;
3733
3734 case STMT_OMP_PARALLEL_DIRECTIVE:
3735 S =
3736 OMPParallelDirective::CreateEmpty(C: Context,
3737 NumClauses: Record[ASTStmtReader::NumStmtFields],
3738 Empty);
3739 break;
3740
3741 case STMT_OMP_SIMD_DIRECTIVE: {
3742 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3743 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3744 S = OMPSimdDirective::CreateEmpty(C: Context, NumClauses,
3745 CollapsedNum, Empty);
3746 break;
3747 }
3748
3749 case STMT_OMP_TILE_DIRECTIVE: {
3750 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3751 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3752 S = OMPTileDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3753 break;
3754 }
3755
3756 case STMP_OMP_STRIPE_DIRECTIVE: {
3757 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3758 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3759 S = OMPStripeDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3760 break;
3761 }
3762
3763 case STMT_OMP_UNROLL_DIRECTIVE: {
3764 assert(Record[ASTStmtReader::NumStmtFields] == 1 && "Unroll directive accepts only a single loop");
3765 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3766 S = OMPUnrollDirective::CreateEmpty(C: Context, NumClauses);
3767 break;
3768 }
3769
3770 case STMT_OMP_REVERSE_DIRECTIVE: {
3771 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3772 assert(Record[ASTStmtReader::NumStmtFields + 1] == 0 &&
3773 "Reverse directive has no clauses");
3774 S = OMPReverseDirective::CreateEmpty(C: Context, NumLoops);
3775 break;
3776 }
3777
3778 case STMT_OMP_SPLIT_DIRECTIVE: {
3779 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3780 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3781 S = OMPSplitDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3782 break;
3783 }
3784
3785 case STMT_OMP_FUSE_DIRECTIVE: {
3786 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3787 S = OMPFuseDirective::CreateEmpty(C: Context, NumClauses);
3788 break;
3789 }
3790
3791 case STMT_OMP_INTERCHANGE_DIRECTIVE: {
3792 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3793 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3794 S = OMPInterchangeDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3795 break;
3796 }
3797
3798 case STMT_OMP_FLATTEN_DIRECTIVE: {
3799 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3800 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3801 S = OMPFlattenDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3802 break;
3803 }
3804
3805 case STMT_OMP_FOR_DIRECTIVE: {
3806 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3807 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3808 S = OMPForDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3809 Empty);
3810 break;
3811 }
3812
3813 case STMT_OMP_FOR_SIMD_DIRECTIVE: {
3814 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3815 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3816 S = OMPForSimdDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3817 Empty);
3818 break;
3819 }
3820
3821 case STMT_OMP_SECTIONS_DIRECTIVE:
3822 S = OMPSectionsDirective::CreateEmpty(
3823 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3824 break;
3825
3826 case STMT_OMP_SECTION_DIRECTIVE:
3827 S = OMPSectionDirective::CreateEmpty(C: Context, Empty);
3828 break;
3829
3830 case STMT_OMP_SCOPE_DIRECTIVE:
3831 S = OMPScopeDirective::CreateEmpty(
3832 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3833 break;
3834
3835 case STMT_OMP_SINGLE_DIRECTIVE:
3836 S = OMPSingleDirective::CreateEmpty(
3837 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3838 break;
3839
3840 case STMT_OMP_MASTER_DIRECTIVE:
3841 S = OMPMasterDirective::CreateEmpty(C: Context, Empty);
3842 break;
3843
3844 case STMT_OMP_CRITICAL_DIRECTIVE:
3845 S = OMPCriticalDirective::CreateEmpty(
3846 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3847 break;
3848
3849 case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
3850 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3851 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3852 S = OMPParallelForDirective::CreateEmpty(C: Context, NumClauses,
3853 CollapsedNum, Empty);
3854 break;
3855 }
3856
3857 case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
3858 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3859 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3860 S = OMPParallelForSimdDirective::CreateEmpty(C: Context, NumClauses,
3861 CollapsedNum, Empty);
3862 break;
3863 }
3864
3865 case STMT_OMP_PARALLEL_MASTER_DIRECTIVE:
3866 S = OMPParallelMasterDirective::CreateEmpty(
3867 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3868 break;
3869
3870 case STMT_OMP_PARALLEL_MASKED_DIRECTIVE:
3871 S = OMPParallelMaskedDirective::CreateEmpty(
3872 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3873 break;
3874
3875 case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
3876 S = OMPParallelSectionsDirective::CreateEmpty(
3877 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3878 break;
3879
3880 case STMT_OMP_TASK_DIRECTIVE:
3881 S = OMPTaskDirective::CreateEmpty(
3882 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3883 break;
3884
3885 case STMT_OMP_TASKYIELD_DIRECTIVE:
3886 S = OMPTaskyieldDirective::CreateEmpty(C: Context, Empty);
3887 break;
3888
3889 case STMT_OMP_BARRIER_DIRECTIVE:
3890 S = OMPBarrierDirective::CreateEmpty(C: Context, Empty);
3891 break;
3892
3893 case STMT_OMP_TASKWAIT_DIRECTIVE:
3894 S = OMPTaskwaitDirective::CreateEmpty(
3895 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3896 break;
3897
3898 case STMT_OMP_ERROR_DIRECTIVE:
3899 S = OMPErrorDirective::CreateEmpty(
3900 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3901 break;
3902
3903 case STMT_OMP_TASKGROUP_DIRECTIVE:
3904 S = OMPTaskgroupDirective::CreateEmpty(
3905 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3906 break;
3907
3908 case STMT_OMP_FLUSH_DIRECTIVE:
3909 S = OMPFlushDirective::CreateEmpty(
3910 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3911 break;
3912
3913 case STMT_OMP_DEPOBJ_DIRECTIVE:
3914 S = OMPDepobjDirective::CreateEmpty(
3915 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3916 break;
3917
3918 case STMT_OMP_SCAN_DIRECTIVE:
3919 S = OMPScanDirective::CreateEmpty(
3920 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3921 break;
3922
3923 case STMT_OMP_ORDERED_STANDALONE_DIRECTIVE: {
3924 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3925 S = OMPOrderedStandaloneDirective::CreateEmpty(C: Context, NumClauses,
3926 Empty);
3927 break;
3928 }
3929
3930 case STMT_OMP_ORDERED_BLOCK_ASSOC_DIRECTIVE: {
3931 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3932 S = OMPOrderedBlockAssocDirective::CreateEmpty(C: Context, NumClauses,
3933 Empty);
3934 break;
3935 }
3936
3937 case STMT_OMP_ATOMIC_DIRECTIVE:
3938 S = OMPAtomicDirective::CreateEmpty(
3939 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3940 break;
3941
3942 case STMT_OMP_TARGET_DIRECTIVE:
3943 S = OMPTargetDirective::CreateEmpty(
3944 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3945 break;
3946
3947 case STMT_OMP_TARGET_DATA_DIRECTIVE:
3948 S = OMPTargetDataDirective::CreateEmpty(
3949 C: Context, N: Record[ASTStmtReader::NumStmtFields], Empty);
3950 break;
3951
3952 case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE:
3953 S = OMPTargetEnterDataDirective::CreateEmpty(
3954 C: Context, N: Record[ASTStmtReader::NumStmtFields], Empty);
3955 break;
3956
3957 case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE:
3958 S = OMPTargetExitDataDirective::CreateEmpty(
3959 C: Context, N: Record[ASTStmtReader::NumStmtFields], Empty);
3960 break;
3961
3962 case STMT_OMP_TARGET_PARALLEL_DIRECTIVE:
3963 S = OMPTargetParallelDirective::CreateEmpty(
3964 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3965 break;
3966
3967 case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: {
3968 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3969 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3970 S = OMPTargetParallelForDirective::CreateEmpty(C: Context, NumClauses,
3971 CollapsedNum, Empty);
3972 break;
3973 }
3974
3975 case STMT_OMP_TARGET_UPDATE_DIRECTIVE:
3976 S = OMPTargetUpdateDirective::CreateEmpty(
3977 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3978 break;
3979
3980 case STMT_OMP_TEAMS_DIRECTIVE:
3981 S = OMPTeamsDirective::CreateEmpty(
3982 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3983 break;
3984
3985 case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
3986 S = OMPCancellationPointDirective::CreateEmpty(C: Context, Empty);
3987 break;
3988
3989 case STMT_OMP_CANCEL_DIRECTIVE:
3990 S = OMPCancelDirective::CreateEmpty(
3991 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3992 break;
3993
3994 case STMT_OMP_TASKLOOP_DIRECTIVE: {
3995 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3996 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3997 S = OMPTaskLoopDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3998 Empty);
3999 break;
4000 }
4001
4002 case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
4003 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4004 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4005 S = OMPTaskLoopSimdDirective::CreateEmpty(C: Context, NumClauses,
4006 CollapsedNum, Empty);
4007 break;
4008 }
4009
4010 case STMT_OMP_MASTER_TASKLOOP_DIRECTIVE: {
4011 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4012 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4013 S = OMPMasterTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
4014 CollapsedNum, Empty);
4015 break;
4016 }
4017
4018 case STMT_OMP_MASKED_TASKLOOP_DIRECTIVE: {
4019 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4020 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4021 S = OMPMaskedTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
4022 CollapsedNum, Empty);
4023 break;
4024 }
4025
4026 case STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
4027 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4028 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4029 S = OMPMasterTaskLoopSimdDirective::CreateEmpty(C: Context, NumClauses,
4030 CollapsedNum, Empty);
4031 break;
4032 }
4033
4034 case STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE: {
4035 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4036 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4037 S = OMPMaskedTaskLoopSimdDirective::CreateEmpty(C: Context, NumClauses,
4038 CollapsedNum, Empty);
4039 break;
4040 }
4041
4042 case STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE: {
4043 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4044 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4045 S = OMPParallelMasterTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
4046 CollapsedNum, Empty);
4047 break;
4048 }
4049
4050 case STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE: {
4051 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4052 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4053 S = OMPParallelMaskedTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
4054 CollapsedNum, Empty);
4055 break;
4056 }
4057
4058 case STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
4059 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4060 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4061 S = OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(
4062 C: Context, NumClauses, CollapsedNum, Empty);
4063 break;
4064 }
4065
4066 case STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE: {
4067 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4068 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4069 S = OMPParallelMaskedTaskLoopSimdDirective::CreateEmpty(
4070 C: Context, NumClauses, CollapsedNum, Empty);
4071 break;
4072 }
4073
4074 case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
4075 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4076 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4077 S = OMPDistributeDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
4078 Empty);
4079 break;
4080 }
4081
4082 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
4083 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4084 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4085 S = OMPDistributeParallelForDirective::CreateEmpty(C: Context, NumClauses,
4086 CollapsedNum, Empty);
4087 break;
4088 }
4089
4090 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
4091 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4092 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4093 S = OMPDistributeParallelForSimdDirective::CreateEmpty(C: Context, NumClauses,
4094 CollapsedNum,
4095 Empty);
4096 break;
4097 }
4098
4099 case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: {
4100 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4101 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4102 S = OMPDistributeSimdDirective::CreateEmpty(C: Context, NumClauses,
4103 CollapsedNum, Empty);
4104 break;
4105 }
4106
4107 case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: {
4108 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4109 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4110 S = OMPTargetParallelForSimdDirective::CreateEmpty(C: Context, NumClauses,
4111 CollapsedNum, Empty);
4112 break;
4113 }
4114
4115 case STMT_OMP_TARGET_SIMD_DIRECTIVE: {
4116 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4117 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4118 S = OMPTargetSimdDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
4119 Empty);
4120 break;
4121 }
4122
4123 case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: {
4124 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4125 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4126 S = OMPTeamsDistributeDirective::CreateEmpty(C: Context, NumClauses,
4127 CollapsedNum, Empty);
4128 break;
4129 }
4130
4131 case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
4132 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4133 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4134 S = OMPTeamsDistributeSimdDirective::CreateEmpty(C: Context, NumClauses,
4135 CollapsedNum, Empty);
4136 break;
4137 }
4138
4139 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
4140 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4141 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4142 S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(
4143 C: Context, NumClauses, CollapsedNum, Empty);
4144 break;
4145 }
4146
4147 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
4148 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4149 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4150 S = OMPTeamsDistributeParallelForDirective::CreateEmpty(
4151 C: Context, NumClauses, CollapsedNum, Empty);
4152 break;
4153 }
4154
4155 case STMT_OMP_TARGET_TEAMS_DIRECTIVE:
4156 S = OMPTargetTeamsDirective::CreateEmpty(
4157 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4158 break;
4159
4160 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: {
4161 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4162 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4163 S = OMPTargetTeamsDistributeDirective::CreateEmpty(C: Context, NumClauses,
4164 CollapsedNum, Empty);
4165 break;
4166 }
4167
4168 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
4169 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4170 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4171 S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(
4172 C: Context, NumClauses, CollapsedNum, Empty);
4173 break;
4174 }
4175
4176 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
4177 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4178 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4179 S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
4180 C: Context, NumClauses, CollapsedNum, Empty);
4181 break;
4182 }
4183
4184 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
4185 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4186 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4187 S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty(
4188 C: Context, NumClauses, CollapsedNum, Empty);
4189 break;
4190 }
4191
4192 case STMT_OMP_INTEROP_DIRECTIVE:
4193 S = OMPInteropDirective::CreateEmpty(
4194 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4195 break;
4196
4197 case STMT_OMP_DISPATCH_DIRECTIVE:
4198 S = OMPDispatchDirective::CreateEmpty(
4199 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4200 break;
4201
4202 case STMT_OMP_MASKED_DIRECTIVE:
4203 S = OMPMaskedDirective::CreateEmpty(
4204 C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4205 break;
4206
4207 case STMT_OMP_GENERIC_LOOP_DIRECTIVE: {
4208 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4209 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4210 S = OMPGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4211 CollapsedNum, Empty);
4212 break;
4213 }
4214
4215 case STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE: {
4216 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4217 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4218 S = OMPTeamsGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4219 CollapsedNum, Empty);
4220 break;
4221 }
4222
4223 case STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE: {
4224 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4225 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4226 S = OMPTargetTeamsGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4227 CollapsedNum, Empty);
4228 break;
4229 }
4230
4231 case STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE: {
4232 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4233 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4234 S = OMPParallelGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4235 CollapsedNum, Empty);
4236 break;
4237 }
4238
4239 case STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE: {
4240 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4241 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4242 S = OMPTargetParallelGenericLoopDirective::CreateEmpty(
4243 C: Context, NumClauses, CollapsedNum, Empty);
4244 break;
4245 }
4246
4247 case STMT_OMP_ASSUME_DIRECTIVE: {
4248 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4249 S = OMPAssumeDirective::CreateEmpty(C: Context, NumClauses, Empty);
4250 break;
4251 }
4252
4253 case EXPR_CXX_OPERATOR_CALL: {
4254 auto NumArgs = Record[ASTStmtReader::NumExprFields];
4255 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4256 CallExprBits.advance(BitsWidth: 1);
4257 auto HasFPFeatures = CallExprBits.getNextBit();
4258 S = CXXOperatorCallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures,
4259 Empty);
4260 break;
4261 }
4262
4263 case EXPR_CXX_MEMBER_CALL: {
4264 auto NumArgs = Record[ASTStmtReader::NumExprFields];
4265 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4266 CallExprBits.advance(BitsWidth: 1);
4267 auto HasFPFeatures = CallExprBits.getNextBit();
4268 S = CXXMemberCallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures,
4269 Empty);
4270 break;
4271 }
4272
4273 case EXPR_CXX_REWRITTEN_BINARY_OPERATOR:
4274 S = new (Context) CXXRewrittenBinaryOperator(Empty);
4275 break;
4276
4277 case EXPR_CXX_CONSTRUCT:
4278 S = CXXConstructExpr::CreateEmpty(
4279 Ctx: Context,
4280 /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
4281 break;
4282
4283 case EXPR_CXX_INHERITED_CTOR_INIT:
4284 S = new (Context) CXXInheritedCtorInitExpr(Empty);
4285 break;
4286
4287 case EXPR_CXX_TEMPORARY_OBJECT:
4288 S = CXXTemporaryObjectExpr::CreateEmpty(
4289 Ctx: Context,
4290 /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
4291 break;
4292
4293 case EXPR_CXX_STATIC_CAST: {
4294 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4295 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4296 CastExprBits.advance(BitsWidth: 7);
4297 bool HasFPFeatures = CastExprBits.getNextBit();
4298 S = CXXStaticCastExpr::CreateEmpty(Context, PathSize, hasFPFeatures: HasFPFeatures);
4299 break;
4300 }
4301
4302 case EXPR_CXX_DYNAMIC_CAST: {
4303 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4304 S = CXXDynamicCastExpr::CreateEmpty(Context, pathSize: PathSize);
4305 break;
4306 }
4307
4308 case EXPR_CXX_REINTERPRET_CAST: {
4309 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4310 S = CXXReinterpretCastExpr::CreateEmpty(Context, pathSize: PathSize);
4311 break;
4312 }
4313
4314 case EXPR_CXX_CONST_CAST:
4315 S = CXXConstCastExpr::CreateEmpty(Context);
4316 break;
4317
4318 case EXPR_CXX_ADDRSPACE_CAST:
4319 S = CXXAddrspaceCastExpr::CreateEmpty(Context);
4320 break;
4321
4322 case EXPR_CXX_FUNCTIONAL_CAST: {
4323 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4324 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4325 CastExprBits.advance(BitsWidth: 7);
4326 bool HasFPFeatures = CastExprBits.getNextBit();
4327 S = CXXFunctionalCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures);
4328 break;
4329 }
4330
4331 case EXPR_BUILTIN_BIT_CAST: {
4332#ifndef NDEBUG
4333 unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4334 assert(PathSize == 0 && "Wrong PathSize!");
4335#endif
4336 S = new (Context) BuiltinBitCastExpr(Empty);
4337 break;
4338 }
4339
4340 case EXPR_USER_DEFINED_LITERAL: {
4341 auto NumArgs = Record[ASTStmtReader::NumExprFields];
4342 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4343 CallExprBits.advance(BitsWidth: 1);
4344 auto HasFPFeatures = CallExprBits.getNextBit();
4345 S = UserDefinedLiteral::CreateEmpty(Ctx: Context, NumArgs, HasFPOptions: HasFPFeatures,
4346 Empty);
4347 break;
4348 }
4349
4350 case EXPR_CXX_STD_INITIALIZER_LIST:
4351 S = new (Context) CXXStdInitializerListExpr(Empty);
4352 break;
4353
4354 case EXPR_CXX_BOOL_LITERAL:
4355 S = new (Context) CXXBoolLiteralExpr(Empty);
4356 break;
4357
4358 case EXPR_CXX_NULL_PTR_LITERAL:
4359 S = new (Context) CXXNullPtrLiteralExpr(Empty);
4360 break;
4361
4362 case EXPR_CXX_TYPEID_EXPR:
4363 S = new (Context) CXXTypeidExpr(Empty, true);
4364 break;
4365
4366 case EXPR_CXX_TYPEID_TYPE:
4367 S = new (Context) CXXTypeidExpr(Empty, false);
4368 break;
4369
4370 case EXPR_CXX_UUIDOF_EXPR:
4371 S = new (Context) CXXUuidofExpr(Empty, true);
4372 break;
4373
4374 case EXPR_CXX_PROPERTY_REF_EXPR:
4375 S = new (Context) MSPropertyRefExpr(Empty);
4376 break;
4377
4378 case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
4379 S = new (Context) MSPropertySubscriptExpr(Empty);
4380 break;
4381
4382 case EXPR_CXX_UUIDOF_TYPE:
4383 S = new (Context) CXXUuidofExpr(Empty, false);
4384 break;
4385
4386 case EXPR_CXX_THIS:
4387 S = CXXThisExpr::CreateEmpty(Ctx: Context);
4388 break;
4389
4390 case EXPR_CXX_THROW:
4391 S = new (Context) CXXThrowExpr(Empty);
4392 break;
4393
4394 case EXPR_CXX_DEFAULT_ARG:
4395 S = CXXDefaultArgExpr::CreateEmpty(
4396 C: Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
4397 break;
4398
4399 case EXPR_CXX_DEFAULT_INIT:
4400 S = CXXDefaultInitExpr::CreateEmpty(
4401 C: Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
4402 break;
4403
4404 case EXPR_CXX_BIND_TEMPORARY:
4405 S = new (Context) CXXBindTemporaryExpr(Empty);
4406 break;
4407
4408 case EXPR_CXX_SCALAR_VALUE_INIT:
4409 S = new (Context) CXXScalarValueInitExpr(Empty);
4410 break;
4411
4412 case EXPR_CXX_NEW:
4413 S = CXXNewExpr::CreateEmpty(
4414 Ctx: Context,
4415 /*IsArray=*/Record[ASTStmtReader::NumExprFields],
4416 /*HasInit=*/Record[ASTStmtReader::NumExprFields + 1],
4417 /*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2],
4418 /*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]);
4419 break;
4420
4421 case EXPR_CXX_DELETE:
4422 S = new (Context) CXXDeleteExpr(Empty);
4423 break;
4424
4425 case EXPR_CXX_PSEUDO_DESTRUCTOR:
4426 S = new (Context) CXXPseudoDestructorExpr(Empty);
4427 break;
4428
4429 case EXPR_EXPR_WITH_CLEANUPS:
4430 S = ExprWithCleanups::Create(C: Context, empty: Empty,
4431 numObjects: Record[ASTStmtReader::NumExprFields]);
4432 break;
4433
4434 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: {
4435 unsigned NumTemplateArgs = Record[ASTStmtReader::NumExprFields];
4436 BitsUnpacker DependentScopeMemberBits(
4437 Record[ASTStmtReader::NumExprFields + 1]);
4438 bool HasTemplateKWAndArgsInfo = DependentScopeMemberBits.getNextBit();
4439
4440 bool HasFirstQualifierFoundInScope =
4441 DependentScopeMemberBits.getNextBit();
4442 S = CXXDependentScopeMemberExpr::CreateEmpty(
4443 Ctx: Context, HasTemplateKWAndArgsInfo, NumTemplateArgs,
4444 HasFirstQualifierFoundInScope);
4445 break;
4446 }
4447
4448 case EXPR_DEPENDENT_TEMPLATE_ID:
4449 S = DependentTemplateIdExpr::CreateEmpty(
4450 Context, /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]);
4451 break;
4452
4453 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: {
4454 BitsUnpacker DependentScopeDeclRefBits(
4455 Record[ASTStmtReader::NumStmtFields]);
4456 DependentScopeDeclRefBits.advance(BitsWidth: ASTStmtReader::NumExprBits);
4457 bool HasTemplateKWAndArgsInfo = DependentScopeDeclRefBits.getNextBit();
4458 unsigned NumTemplateArgs =
4459 HasTemplateKWAndArgsInfo
4460 ? DependentScopeDeclRefBits.getNextBits(/*Width=*/16)
4461 : 0;
4462 S = DependentScopeDeclRefExpr::CreateEmpty(
4463 Context, HasTemplateKWAndArgsInfo, NumTemplateArgs);
4464 break;
4465 }
4466
4467 case EXPR_CXX_UNRESOLVED_CONSTRUCT:
4468 S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
4469 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
4470 break;
4471
4472 case EXPR_CXX_UNRESOLVED_MEMBER: {
4473 auto NumResults = Record[ASTStmtReader::NumExprFields];
4474 BitsUnpacker OverloadExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4475 auto HasTemplateKWAndArgsInfo = OverloadExprBits.getNextBit();
4476 auto NumTemplateArgs = HasTemplateKWAndArgsInfo
4477 ? Record[ASTStmtReader::NumExprFields + 2]
4478 : 0;
4479 S = UnresolvedMemberExpr::CreateEmpty(
4480 Context, NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
4481 break;
4482 }
4483
4484 case EXPR_CXX_UNRESOLVED_LOOKUP: {
4485 auto NumResults = Record[ASTStmtReader::NumExprFields];
4486 BitsUnpacker OverloadExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4487 auto HasTemplateKWAndArgsInfo = OverloadExprBits.getNextBit();
4488 auto NumTemplateArgs = HasTemplateKWAndArgsInfo
4489 ? Record[ASTStmtReader::NumExprFields + 2]
4490 : 0;
4491 S = UnresolvedLookupExpr::CreateEmpty(
4492 Context, NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
4493 break;
4494 }
4495
4496 case EXPR_TYPE_TRAIT:
4497 S = TypeTraitExpr::CreateDeserialized(
4498 C: Context, IsStoredAsBool: Record[ASTStmtReader::NumExprFields],
4499 NumArgs: Record[ASTStmtReader::NumExprFields + 2]);
4500 break;
4501
4502 case EXPR_ARRAY_TYPE_TRAIT:
4503 S = new (Context) ArrayTypeTraitExpr(Empty);
4504 break;
4505
4506 case EXPR_CXX_EXPRESSION_TRAIT:
4507 S = new (Context) ExpressionTraitExpr(Empty);
4508 break;
4509
4510 case EXPR_CXX_NOEXCEPT:
4511 S = new (Context) CXXNoexceptExpr(Empty);
4512 break;
4513
4514 case EXPR_PACK_EXPANSION:
4515 S = new (Context) PackExpansionExpr(Empty);
4516 break;
4517
4518 case EXPR_SIZEOF_PACK:
4519 S = SizeOfPackExpr::CreateDeserialized(
4520 Context,
4521 /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
4522 break;
4523
4524 case EXPR_PACK_INDEXING:
4525 S = PackIndexingExpr::CreateDeserialized(
4526 Context,
4527 /*TransformedExprs=*/NumTransformedExprs: Record[ASTStmtReader::NumExprFields]);
4528 break;
4529
4530 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
4531 S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
4532 break;
4533
4534 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
4535 S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
4536 break;
4537
4538 case EXPR_FUNCTION_PARM_PACK:
4539 S = FunctionParmPackExpr::CreateEmpty(Context,
4540 NumParams: Record[ASTStmtReader::NumExprFields]);
4541 break;
4542
4543 case EXPR_MATERIALIZE_TEMPORARY:
4544 S = new (Context) MaterializeTemporaryExpr(Empty);
4545 break;
4546
4547 case EXPR_CXX_FOLD:
4548 S = new (Context) CXXFoldExpr(Empty);
4549 break;
4550
4551 case EXPR_CXX_PAREN_LIST_INIT:
4552 S = CXXParenListInitExpr::CreateEmpty(
4553 C&: Context, /*numExprs=*/Record[ASTStmtReader::NumExprFields], Empty);
4554 break;
4555
4556 case EXPR_OPAQUE_VALUE:
4557 S = new (Context) OpaqueValueExpr(Empty);
4558 break;
4559
4560 case EXPR_CUDA_KERNEL_CALL: {
4561 auto NumArgs = Record[ASTStmtReader::NumExprFields];
4562 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4563 CallExprBits.advance(BitsWidth: 1);
4564 auto HasFPFeatures = CallExprBits.getNextBit();
4565 S = CUDAKernelCallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures,
4566 Empty);
4567 break;
4568 }
4569
4570 case EXPR_ASTYPE:
4571 S = new (Context) AsTypeExpr(Empty);
4572 break;
4573
4574 case EXPR_PSEUDO_OBJECT: {
4575 unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
4576 S = PseudoObjectExpr::Create(Context, shell: Empty, numSemanticExprs);
4577 break;
4578 }
4579
4580 case EXPR_ATOMIC:
4581 S = new (Context) AtomicExpr(Empty);
4582 break;
4583
4584 case EXPR_LAMBDA: {
4585 unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
4586 S = LambdaExpr::CreateDeserialized(C: Context, NumCaptures);
4587 break;
4588 }
4589
4590 case STMT_COROUTINE_BODY: {
4591 unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
4592 S = CoroutineBodyStmt::Create(C: Context, Empty, NumParams);
4593 break;
4594 }
4595
4596 case STMT_CORETURN:
4597 S = new (Context) CoreturnStmt(Empty);
4598 break;
4599
4600 case EXPR_COAWAIT:
4601 S = new (Context) CoawaitExpr(Empty);
4602 break;
4603
4604 case EXPR_COYIELD:
4605 S = new (Context) CoyieldExpr(Empty);
4606 break;
4607
4608 case EXPR_DEPENDENT_COAWAIT:
4609 S = new (Context) DependentCoawaitExpr(Empty);
4610 break;
4611
4612 case EXPR_CONCEPT_SPECIALIZATION: {
4613 S = new (Context) ConceptSpecializationExpr(Empty);
4614 break;
4615 }
4616
4617 case EXPR_CXX_EXPANSION_SELECT:
4618 S = new (Context) CXXExpansionSelectExpr(Empty);
4619 break;
4620
4621 case STMT_OPENACC_COMPUTE_CONSTRUCT: {
4622 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4623 S = OpenACCComputeConstruct::CreateEmpty(C: Context, NumClauses);
4624 break;
4625 }
4626 case STMT_OPENACC_LOOP_CONSTRUCT: {
4627 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4628 S = OpenACCLoopConstruct::CreateEmpty(C: Context, NumClauses);
4629 break;
4630 }
4631 case STMT_OPENACC_COMBINED_CONSTRUCT: {
4632 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4633 S = OpenACCCombinedConstruct::CreateEmpty(C: Context, NumClauses);
4634 break;
4635 }
4636 case STMT_OPENACC_DATA_CONSTRUCT: {
4637 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4638 S = OpenACCDataConstruct::CreateEmpty(C: Context, NumClauses);
4639 break;
4640 }
4641 case STMT_OPENACC_ENTER_DATA_CONSTRUCT: {
4642 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4643 S = OpenACCEnterDataConstruct::CreateEmpty(C: Context, NumClauses);
4644 break;
4645 }
4646 case STMT_OPENACC_EXIT_DATA_CONSTRUCT: {
4647 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4648 S = OpenACCExitDataConstruct::CreateEmpty(C: Context, NumClauses);
4649 break;
4650 }
4651 case STMT_OPENACC_HOST_DATA_CONSTRUCT: {
4652 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4653 S = OpenACCHostDataConstruct::CreateEmpty(C: Context, NumClauses);
4654 break;
4655 }
4656 case STMT_OPENACC_WAIT_CONSTRUCT: {
4657 unsigned NumExprs = Record[ASTStmtReader::NumStmtFields];
4658 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4659 S = OpenACCWaitConstruct::CreateEmpty(C: Context, NumExprs, NumClauses);
4660 break;
4661 }
4662 case STMT_OPENACC_CACHE_CONSTRUCT: {
4663 unsigned NumVars = Record[ASTStmtReader::NumStmtFields];
4664 S = OpenACCCacheConstruct::CreateEmpty(C: Context, NumVars);
4665 break;
4666 }
4667 case STMT_OPENACC_INIT_CONSTRUCT: {
4668 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4669 S = OpenACCInitConstruct::CreateEmpty(C: Context, NumClauses);
4670 break;
4671 }
4672 case STMT_OPENACC_SHUTDOWN_CONSTRUCT: {
4673 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4674 S = OpenACCShutdownConstruct::CreateEmpty(C: Context, NumClauses);
4675 break;
4676 }
4677 case STMT_OPENACC_SET_CONSTRUCT: {
4678 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4679 S = OpenACCSetConstruct::CreateEmpty(C: Context, NumClauses);
4680 break;
4681 }
4682 case STMT_OPENACC_UPDATE_CONSTRUCT: {
4683 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4684 S = OpenACCUpdateConstruct::CreateEmpty(C: Context, NumClauses);
4685 break;
4686 }
4687 case STMT_OPENACC_ATOMIC_CONSTRUCT: {
4688 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4689 S = OpenACCAtomicConstruct::CreateEmpty(C: Context, NumClauses);
4690 break;
4691 }
4692 case EXPR_REQUIRES: {
4693 unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields];
4694 unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1];
4695 S = RequiresExpr::Create(C&: Context, Empty, NumLocalParameters: numLocalParameters,
4696 NumRequirements: numRequirement);
4697 break;
4698 }
4699 case EXPR_HLSL_OUT_ARG:
4700 S = HLSLOutArgExpr::CreateEmpty(Ctx: Context);
4701 break;
4702 case EXPR_REFLECT: {
4703 S = CXXReflectExpr::CreateEmpty(C&: Context);
4704 break;
4705 }
4706 }
4707
4708 // We hit a STMT_STOP, so we're done with this expression.
4709 if (Finished)
4710 break;
4711
4712 ++NumStatementsRead;
4713
4714 if (S && !IsStmtReference) {
4715 Reader.Visit(S);
4716 StmtEntries[Cursor.GetCurrentBitNo()] = S;
4717 }
4718
4719 assert(Record.getIdx() == Record.size() &&
4720 "Invalid deserialization of statement");
4721 StmtStack.push_back(Elt: S);
4722 }
4723Done:
4724 assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
4725 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
4726 return StmtStack.pop_back_val();
4727}
4728