Bug Summary

File:clang/lib/Serialization/ASTReaderStmt.cpp
Warning:line 1105, column 16
Although the value stored to 'opc' is used in the enclosing expression, the value is never actually read from 'opc'

Annotated Source Code

Press '?' to see keyboard shortcuts

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