Bug Summary

File:include/llvm/Bitcode/BitstreamReader.h
Warning:line 210, 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-eagerly-assume -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 -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-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/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-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/Serialization -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -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-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Serialization/ASTReaderStmt.cpp -faddrsig

/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Serialization/ASTReaderStmt.cpp

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

/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Bitcode/BitstreamReader.h

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