Bug Summary

File:tools/clang/lib/Serialization/ASTReaderStmt.cpp
Warning:line 1951, column 3
1st function call argument is an uninitialized value

Annotated Source Code

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