Bug Summary

File:include/llvm/Bitcode/BitstreamReader.h
Warning:line 208, column 39
The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-9/lib/clang/9.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn362543/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/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/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.0.0/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++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/lib/Serialization -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn362543=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2019-06-05-060531-1271-1 -x c++ /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReaderStmt.cpp -faddrsig

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

/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h

1//===- BitstreamReader.h - Low-level bitstream reader interface -*- C++ -*-===//
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// This header defines the BitstreamReader class. This class can be used to
10// read an arbitrary bitstream, regardless of its contents.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_BITCODE_BITSTREAMREADER_H
15#define LLVM_BITCODE_BITSTREAMREADER_H
16
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/Bitcode/BitCodes.h"
20#include "llvm/Support/Endian.h"
21#include "llvm/Support/ErrorHandling.h"
22#include "llvm/Support/MathExtras.h"
23#include "llvm/Support/MemoryBuffer.h"
24#include <algorithm>
25#include <cassert>
26#include <climits>
27#include <cstddef>
28#include <cstdint>
29#include <memory>
30#include <string>
31#include <utility>
32#include <vector>
33
34namespace llvm {
35
36/// This class maintains the abbreviations read from a block info block.
37class BitstreamBlockInfo {
38public:
39 /// This contains information emitted to BLOCKINFO_BLOCK blocks. These
40 /// describe abbreviations that all blocks of the specified ID inherit.
41 struct BlockInfo {
42 unsigned BlockID;
43 std::vector<std::shared_ptr<BitCodeAbbrev>> Abbrevs;
44 std::string Name;
45 std::vector<std::pair<unsigned, std::string>> RecordNames;
46 };
47
48private:
49 std::vector<BlockInfo> BlockInfoRecords;
50
51public:
52 /// If there is block info for the specified ID, return it, otherwise return
53 /// null.
54 const BlockInfo *getBlockInfo(unsigned BlockID) const {
55 // Common case, the most recent entry matches BlockID.
56 if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
57 return &BlockInfoRecords.back();
58
59 for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
60 i != e; ++i)
61 if (BlockInfoRecords[i].BlockID == BlockID)
62 return &BlockInfoRecords[i];
63 return nullptr;
64 }
65
66 BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
67 if (const BlockInfo *BI = getBlockInfo(BlockID))
68 return *const_cast<BlockInfo*>(BI);
69
70 // Otherwise, add a new record.
71 BlockInfoRecords.emplace_back();
72 BlockInfoRecords.back().BlockID = BlockID;
73 return BlockInfoRecords.back();
74 }
75};
76
77/// This represents a position within a bitstream. There may be multiple
78/// independent cursors reading within one bitstream, each maintaining their
79/// own local state.
80class SimpleBitstreamCursor {
81 ArrayRef<uint8_t> BitcodeBytes;
82 size_t NextChar = 0;
83
84public:
85 /// This is the current data we have pulled from the stream but have not
86 /// returned to the client. This is specifically and intentionally defined to
87 /// follow the word size of the host machine for efficiency. We use word_t in
88 /// places that are aware of this to make it perfectly explicit what is going
89 /// on.
90 using word_t = size_t;
91
92private:
93 word_t CurWord = 0;
94
95 /// This is the number of bits in CurWord that are valid. This is always from
96 /// [0...bits_of(size_t)-1] inclusive.
97 unsigned BitsInCurWord = 0;
98
99public:
100 static const size_t MaxChunkSize = sizeof(word_t) * 8;
101
102 SimpleBitstreamCursor() = default;
103 explicit SimpleBitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
104 : BitcodeBytes(BitcodeBytes) {}
105 explicit SimpleBitstreamCursor(StringRef BitcodeBytes)
106 : BitcodeBytes(arrayRefFromStringRef(BitcodeBytes)) {}
107 explicit SimpleBitstreamCursor(MemoryBufferRef BitcodeBytes)
108 : SimpleBitstreamCursor(BitcodeBytes.getBuffer()) {}
109
110 bool canSkipToPos(size_t pos) const {
111 // pos can be skipped to if it is a valid address or one byte past the end.
112 return pos <= BitcodeBytes.size();
113 }
114
115 bool AtEndOfStream() {
116 return BitsInCurWord == 0 && BitcodeBytes.size() <= NextChar;
117 }
118
119 /// Return the bit # of the bit we are reading.
120 uint64_t GetCurrentBitNo() const {
121 return NextChar*CHAR_BIT8 - BitsInCurWord;
122 }
123
124 // Return the byte # of the current bit.
125 uint64_t getCurrentByteNo() const { return GetCurrentBitNo() / 8; }
126
127 ArrayRef<uint8_t> getBitcodeBytes() const { return BitcodeBytes; }
128
129 /// Reset the stream to the specified bit number.
130 void JumpToBit(uint64_t BitNo) {
131 size_t ByteNo = size_t(BitNo/8) & ~(sizeof(word_t)-1);
132 unsigned WordBitNo = unsigned(BitNo & (sizeof(word_t)*8-1));
133 assert(canSkipToPos(ByteNo) && "Invalid location")((canSkipToPos(ByteNo) && "Invalid location") ? static_cast
<void> (0) : __assert_fail ("canSkipToPos(ByteNo) && \"Invalid location\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 133, __PRETTY_FUNCTION__))
;
134
135 // Move the cursor to the right word.
136 NextChar = ByteNo;
137 BitsInCurWord = 0;
138
139 // Skip over any bits that are already consumed.
140 if (WordBitNo)
141 Read(WordBitNo);
142 }
143
144 /// Get a pointer into the bitstream at the specified byte offset.
145 const uint8_t *getPointerToByte(uint64_t ByteNo, uint64_t NumBytes) {
146 return BitcodeBytes.data() + ByteNo;
147 }
148
149 /// Get a pointer into the bitstream at the specified bit offset.
150 ///
151 /// The bit offset must be on a byte boundary.
152 const uint8_t *getPointerToBit(uint64_t BitNo, uint64_t NumBytes) {
153 assert(!(BitNo % 8) && "Expected bit on byte boundary")((!(BitNo % 8) && "Expected bit on byte boundary") ? static_cast
<void> (0) : __assert_fail ("!(BitNo % 8) && \"Expected bit on byte boundary\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 153, __PRETTY_FUNCTION__))
;
154 return getPointerToByte(BitNo / 8, NumBytes);
155 }
156
157 void fillCurWord() {
158 if (NextChar >= BitcodeBytes.size())
159 report_fatal_error("Unexpected end of file");
160
161 // Read the next word from the stream.
162 const uint8_t *NextCharPtr = BitcodeBytes.data() + NextChar;
163 unsigned BytesRead;
164 if (BitcodeBytes.size() >= NextChar + sizeof(word_t)) {
165 BytesRead = sizeof(word_t);
166 CurWord =
167 support::endian::read<word_t, support::little, support::unaligned>(
168 NextCharPtr);
169 } else {
170 // Short read.
171 BytesRead = BitcodeBytes.size() - NextChar;
172 CurWord = 0;
173 for (unsigned B = 0; B != BytesRead; ++B)
174 CurWord |= uint64_t(NextCharPtr[B]) << (B * 8);
175 }
176 NextChar += BytesRead;
177 BitsInCurWord = BytesRead * 8;
178 }
179
180 word_t Read(unsigned NumBits) {
181 static const unsigned BitsInWord = MaxChunkSize;
182
183 assert(NumBits && NumBits <= BitsInWord &&((NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!"
) ? static_cast<void> (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 184, __PRETTY_FUNCTION__))
9
Assuming 'NumBits' is not equal to 0
10
Assuming 'NumBits' is <= 'BitsInWord'
11
'?' condition is true
184 "Cannot return zero or more than BitsInWord bits!")((NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!"
) ? static_cast<void> (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 184, __PRETTY_FUNCTION__))
;
185
186 static const unsigned Mask = sizeof(word_t) > 4 ? 0x3f : 0x1f;
12
'?' condition is true
187
188 // If the field is fully contained by CurWord, return it quickly.
189 if (BitsInCurWord >= NumBits) {
13
Assuming the condition is false
14
Taking false branch
190 word_t R = CurWord & (~word_t(0) >> (BitsInWord - NumBits));
191
192 // Use a mask to avoid undefined behavior.
193 CurWord >>= (NumBits & Mask);
194
195 BitsInCurWord -= NumBits;
196 return R;
197 }
198
199 word_t R = BitsInCurWord ? CurWord : 0;
15
'?' condition is true
200 unsigned BitsLeft = NumBits - BitsInCurWord;
201
202 fillCurWord();
203
204 // If we run out of data, abort.
205 if (BitsLeft > BitsInCurWord)
16
Assuming the condition is false
17
Taking false branch
206 report_fatal_error("Unexpected end of file");
207
208 word_t R2 = CurWord & (~word_t(0) >> (BitsInWord - BitsLeft));
18
The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t'
209
210 // Use a mask to avoid undefined behavior.
211 CurWord >>= (BitsLeft & Mask);
212
213 BitsInCurWord -= BitsLeft;
214
215 R |= R2 << (NumBits - BitsLeft);
216
217 return R;
218 }
219
220 uint32_t ReadVBR(unsigned NumBits) {
221 uint32_t Piece = Read(NumBits);
222 if ((Piece & (1U << (NumBits-1))) == 0)
223 return Piece;
224
225 uint32_t Result = 0;
226 unsigned NextBit = 0;
227 while (true) {
228 Result |= (Piece & ((1U << (NumBits-1))-1)) << NextBit;
229
230 if ((Piece & (1U << (NumBits-1))) == 0)
231 return Result;
232
233 NextBit += NumBits-1;
234 Piece = Read(NumBits);
235 }
236 }
237
238 // Read a VBR that may have a value up to 64-bits in size. The chunk size of
239 // the VBR must still be <= 32 bits though.
240 uint64_t ReadVBR64(unsigned NumBits) {
241 uint32_t Piece = Read(NumBits);
242 if ((Piece & (1U << (NumBits-1))) == 0)
243 return uint64_t(Piece);
244
245 uint64_t Result = 0;
246 unsigned NextBit = 0;
247 while (true) {
248 Result |= uint64_t(Piece & ((1U << (NumBits-1))-1)) << NextBit;
249
250 if ((Piece & (1U << (NumBits-1))) == 0)
251 return Result;
252
253 NextBit += NumBits-1;
254 Piece = Read(NumBits);
255 }
256 }
257
258 void SkipToFourByteBoundary() {
259 // If word_t is 64-bits and if we've read less than 32 bits, just dump
260 // the bits we have up to the next 32-bit boundary.
261 if (sizeof(word_t) > 4 &&
262 BitsInCurWord >= 32) {
263 CurWord >>= BitsInCurWord-32;
264 BitsInCurWord = 32;
265 return;
266 }
267
268 BitsInCurWord = 0;
269 }
270
271 /// Skip to the end of the file.
272 void skipToEnd() { NextChar = BitcodeBytes.size(); }
273};
274
275/// When advancing through a bitstream cursor, each advance can discover a few
276/// different kinds of entries:
277struct BitstreamEntry {
278 enum {
279 Error, // Malformed bitcode was found.
280 EndBlock, // We've reached the end of the current block, (or the end of the
281 // file, which is treated like a series of EndBlock records.
282 SubBlock, // This is the start of a new subblock of a specific ID.
283 Record // This is a record with a specific AbbrevID.
284 } Kind;
285
286 unsigned ID;
287
288 static BitstreamEntry getError() {
289 BitstreamEntry E; E.Kind = Error; return E;
290 }
291
292 static BitstreamEntry getEndBlock() {
293 BitstreamEntry E; E.Kind = EndBlock; return E;
294 }
295
296 static BitstreamEntry getSubBlock(unsigned ID) {
297 BitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E;
298 }
299
300 static BitstreamEntry getRecord(unsigned AbbrevID) {
301 BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E;
302 }
303};
304
305/// This represents a position within a bitcode file, implemented on top of a
306/// SimpleBitstreamCursor.
307///
308/// Unlike iterators, BitstreamCursors are heavy-weight objects that should not
309/// be passed by value.
310class BitstreamCursor : SimpleBitstreamCursor {
311 // This is the declared size of code values used for the current block, in
312 // bits.
313 unsigned CurCodeSize = 2;
314
315 /// Abbrevs installed at in this block.
316 std::vector<std::shared_ptr<BitCodeAbbrev>> CurAbbrevs;
317
318 struct Block {
319 unsigned PrevCodeSize;
320 std::vector<std::shared_ptr<BitCodeAbbrev>> PrevAbbrevs;
321
322 explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
323 };
324
325 /// This tracks the codesize of parent blocks.
326 SmallVector<Block, 8> BlockScope;
327
328 BitstreamBlockInfo *BlockInfo = nullptr;
329
330public:
331 static const size_t MaxChunkSize = sizeof(word_t) * 8;
332
333 BitstreamCursor() = default;
334 explicit BitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
335 : SimpleBitstreamCursor(BitcodeBytes) {}
336 explicit BitstreamCursor(StringRef BitcodeBytes)
337 : SimpleBitstreamCursor(BitcodeBytes) {}
338 explicit BitstreamCursor(MemoryBufferRef BitcodeBytes)
339 : SimpleBitstreamCursor(BitcodeBytes) {}
340
341 using SimpleBitstreamCursor::canSkipToPos;
342 using SimpleBitstreamCursor::AtEndOfStream;
343 using SimpleBitstreamCursor::getBitcodeBytes;
344 using SimpleBitstreamCursor::GetCurrentBitNo;
345 using SimpleBitstreamCursor::getCurrentByteNo;
346 using SimpleBitstreamCursor::getPointerToByte;
347 using SimpleBitstreamCursor::JumpToBit;
348 using SimpleBitstreamCursor::fillCurWord;
349 using SimpleBitstreamCursor::Read;
350 using SimpleBitstreamCursor::ReadVBR;
351 using SimpleBitstreamCursor::ReadVBR64;
352
353 /// Return the number of bits used to encode an abbrev #.
354 unsigned getAbbrevIDWidth() const { return CurCodeSize; }
355
356 /// Flags that modify the behavior of advance().
357 enum {
358 /// If this flag is used, the advance() method does not automatically pop
359 /// the block scope when the end of a block is reached.
360 AF_DontPopBlockAtEnd = 1,
361
362 /// If this flag is used, abbrev entries are returned just like normal
363 /// records.
364 AF_DontAutoprocessAbbrevs = 2
365 };
366
367 /// Advance the current bitstream, returning the next entry in the stream.
368 BitstreamEntry advance(unsigned Flags = 0) {
369 while (true) {
5
Loop condition is true. Entering loop body
370 if (AtEndOfStream())
6
Taking false branch
371 return BitstreamEntry::getError();
372
373 unsigned Code = ReadCode();
7
Calling 'BitstreamCursor::ReadCode'
374 if (Code == bitc::END_BLOCK) {
375 // Pop the end of the block unless Flags tells us not to.
376 if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd())
377 return BitstreamEntry::getError();
378 return BitstreamEntry::getEndBlock();
379 }
380
381 if (Code == bitc::ENTER_SUBBLOCK)
382 return BitstreamEntry::getSubBlock(ReadSubBlockID());
383
384 if (Code == bitc::DEFINE_ABBREV &&
385 !(Flags & AF_DontAutoprocessAbbrevs)) {
386 // We read and accumulate abbrev's, the client can't do anything with
387 // them anyway.
388 ReadAbbrevRecord();
389 continue;
390 }
391
392 return BitstreamEntry::getRecord(Code);
393 }
394 }
395
396 /// This is a convenience function for clients that don't expect any
397 /// subblocks. This just skips over them automatically.
398 BitstreamEntry advanceSkippingSubblocks(unsigned Flags = 0) {
399 while (true) {
3
Loop condition is true. Entering loop body
400 // If we found a normal entry, return it.
401 BitstreamEntry Entry = advance(Flags);
4
Calling 'BitstreamCursor::advance'
402 if (Entry.Kind != BitstreamEntry::SubBlock)
403 return Entry;
404
405 // If we found a sub-block, just skip over it and check the next entry.
406 if (SkipBlock())
407 return BitstreamEntry::getError();
408 }
409 }
410
411 unsigned ReadCode() {
412 return Read(CurCodeSize);
8
Calling 'SimpleBitstreamCursor::Read'
413 }
414
415 // Block header:
416 // [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
417
418 /// Having read the ENTER_SUBBLOCK code, read the BlockID for the block.
419 unsigned ReadSubBlockID() {
420 return ReadVBR(bitc::BlockIDWidth);
421 }
422
423 /// Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body
424 /// of this block. If the block record is malformed, return true.
425 bool SkipBlock() {
426 // Read and ignore the codelen value. Since we are skipping this block, we
427 // don't care what code widths are used inside of it.
428 ReadVBR(bitc::CodeLenWidth);
429 SkipToFourByteBoundary();
430 size_t NumFourBytes = Read(bitc::BlockSizeWidth);
431
432 // Check that the block wasn't partially defined, and that the offset isn't
433 // bogus.
434 size_t SkipTo = GetCurrentBitNo() + NumFourBytes*4*8;
435 if (AtEndOfStream() || !canSkipToPos(SkipTo/8))
436 return true;
437
438 JumpToBit(SkipTo);
439 return false;
440 }
441
442 /// Having read the ENTER_SUBBLOCK abbrevid, enter the block, and return true
443 /// if the block has an error.
444 bool EnterSubBlock(unsigned BlockID, unsigned *NumWordsP = nullptr);
445
446 bool ReadBlockEnd() {
447 if (BlockScope.empty()) return true;
448
449 // Block tail:
450 // [END_BLOCK, <align4bytes>]
451 SkipToFourByteBoundary();
452
453 popBlockScope();
454 return false;
455 }
456
457private:
458 void popBlockScope() {
459 CurCodeSize = BlockScope.back().PrevCodeSize;
460
461 CurAbbrevs = std::move(BlockScope.back().PrevAbbrevs);
462 BlockScope.pop_back();
463 }
464
465 //===--------------------------------------------------------------------===//
466 // Record Processing
467 //===--------------------------------------------------------------------===//
468
469public:
470 /// Return the abbreviation for the specified AbbrevId.
471 const BitCodeAbbrev *getAbbrev(unsigned AbbrevID) {
472 unsigned AbbrevNo = AbbrevID - bitc::FIRST_APPLICATION_ABBREV;
473 if (AbbrevNo >= CurAbbrevs.size())
474 report_fatal_error("Invalid abbrev number");
475 return CurAbbrevs[AbbrevNo].get();
476 }
477
478 /// Read the current record and discard it, returning the code for the record.
479 unsigned skipRecord(unsigned AbbrevID);
480
481 unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
482 StringRef *Blob = nullptr);
483
484 //===--------------------------------------------------------------------===//
485 // Abbrev Processing
486 //===--------------------------------------------------------------------===//
487 void ReadAbbrevRecord();
488
489 /// Read and return a block info block from the bitstream. If an error was
490 /// encountered, return None.
491 ///
492 /// \param ReadBlockInfoNames Whether to read block/record name information in
493 /// the BlockInfo block. Only llvm-bcanalyzer uses this.
494 Optional<BitstreamBlockInfo>
495 ReadBlockInfoBlock(bool ReadBlockInfoNames = false);
496
497 /// Set the block info to be used by this BitstreamCursor to interpret
498 /// abbreviated records.
499 void setBlockInfo(BitstreamBlockInfo *BI) { BlockInfo = BI; }
500};
501
502} // end llvm namespace
503
504#endif // LLVM_BITCODE_BITSTREAMREADER_H