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