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