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