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