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