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