Bug Summary

File:tools/clang/lib/Serialization/ASTReaderStmt.cpp
Warning:line 210, column 39
The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t'

Annotated Source Code

/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp

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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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~svn318882/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;
1775 switch (Reader->Record.readInt()) {
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);
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)
2641 Clauses.push_back(ClauseReader.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);
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 D->setHasCancel(Record.readInt());
2924}
2925
2926void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2927 OMPDistributeParallelForSimdDirective *D) {
2928 VisitOMPLoopDirective(D);
2929}
2930
2931void ASTStmtReader::VisitOMPDistributeSimdDirective(
2932 OMPDistributeSimdDirective *D) {
2933 VisitOMPLoopDirective(D);
2934}
2935
2936void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2937 OMPTargetParallelForSimdDirective *D) {
2938 VisitOMPLoopDirective(D);
2939}
2940
2941void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2942 VisitOMPLoopDirective(D);
2943}
2944
2945void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2946 OMPTeamsDistributeDirective *D) {
2947 VisitOMPLoopDirective(D);
2948}
2949
2950void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2951 OMPTeamsDistributeSimdDirective *D) {
2952 VisitOMPLoopDirective(D);
2953}
2954
2955void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2956 OMPTeamsDistributeParallelForSimdDirective *D) {
2957 VisitOMPLoopDirective(D);
2958}
2959
2960void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2961 OMPTeamsDistributeParallelForDirective *D) {
2962 VisitOMPLoopDirective(D);
2963 D->setHasCancel(Record.readInt());
2964}
2965
2966void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2967 VisitStmt(D);
2968 // The NumClauses field was read in ReadStmtFromStream.
2969 Record.skipInts(1);
2970 VisitOMPExecutableDirective(D);
2971}
2972
2973void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2974 OMPTargetTeamsDistributeDirective *D) {
2975 VisitOMPLoopDirective(D);
2976}
2977
2978void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2979 OMPTargetTeamsDistributeParallelForDirective *D) {
2980 VisitOMPLoopDirective(D);
2981 D->setHasCancel(Record.readInt());
2982}
2983
2984void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2985 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2986 VisitOMPLoopDirective(D);
2987}
2988
2989void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2990 OMPTargetTeamsDistributeSimdDirective *D) {
2991 VisitOMPLoopDirective(D);
2992}
2993
2994//===----------------------------------------------------------------------===//
2995// ASTReader Implementation
2996//===----------------------------------------------------------------------===//
2997
2998Stmt *ASTReader::ReadStmt(ModuleFile &F) {
2999 switch (ReadingKind) {
3000 case Read_None:
3001 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~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3001)
;
3002 case Read_Decl:
3003 case Read_Type:
3004 return ReadStmtFromStream(F);
3005 case Read_Stmt:
3006 return ReadSubStmt();
3007 }
3008
3009 llvm_unreachable("ReadingKind not set ?")::llvm::llvm_unreachable_internal("ReadingKind not set ?", "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3009)
;
3010}
3011
3012Expr *ASTReader::ReadExpr(ModuleFile &F) {
3013 return cast_or_null<Expr>(ReadStmt(F));
3014}
3015
3016Expr *ASTReader::ReadSubExpr() {
3017 return cast_or_null<Expr>(ReadSubStmt());
3018}
3019
3020// Within the bitstream, expressions are stored in Reverse Polish
3021// Notation, with each of the subexpressions preceding the
3022// expression they are stored in. Subexpressions are stored from last to first.
3023// To evaluate expressions, we continue reading expressions and placing them on
3024// the stack, with expressions having operands removing those operands from the
3025// stack. Evaluation terminates when we see a STMT_STOP record, and
3026// the single remaining expression on the stack is our result.
3027Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
3028
3029 ReadingKindTracker ReadingKind(Read_Stmt, *this);
3030 llvm::BitstreamCursor &Cursor = F.DeclsCursor;
3031
3032 // Map of offset to previously deserialized stmt. The offset points
3033 // just after the stmt record.
3034 llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
3035
3036#ifndef NDEBUG
3037 unsigned PrevNumStmts = StmtStack.size();
3038#endif
3039
3040 ASTRecordReader Record(*this, F);
3041 ASTStmtReader Reader(Record, Cursor);
3042 Stmt::EmptyShell Empty;
3043
3044 while (true) {
1
Loop condition is true. Entering loop body
3045 llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();
2
Calling 'BitstreamCursor::advanceSkippingSubblocks'
3046
3047 switch (Entry.Kind) {
3048 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
3049 case llvm::BitstreamEntry::Error:
3050 Error("malformed block record in AST file");
3051 return nullptr;
3052 case llvm::BitstreamEntry::EndBlock:
3053 goto Done;
3054 case llvm::BitstreamEntry::Record:
3055 // The interesting case.
3056 break;
3057 }
3058
3059 ASTContext &Context = getContext();
3060 Stmt *S = nullptr;
3061 bool Finished = false;
3062 bool IsStmtReference = false;
3063 switch ((StmtCode)Record.readRecord(Cursor, Entry.ID)) {
3064 case STMT_STOP:
3065 Finished = true;
3066 break;
3067
3068 case STMT_REF_PTR:
3069 IsStmtReference = true;
3070 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~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3071, __extension__ __PRETTY_FUNCTION__))
3071 "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~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3071, __extension__ __PRETTY_FUNCTION__))
;
3072 S = StmtEntries[Record.readInt()];
3073 break;
3074
3075 case STMT_NULL_PTR:
3076 S = nullptr;
3077 break;
3078
3079 case STMT_NULL:
3080 S = new (Context) NullStmt(Empty);
3081 break;
3082
3083 case STMT_COMPOUND:
3084 S = new (Context) CompoundStmt(Empty);
3085 break;
3086
3087 case STMT_CASE:
3088 S = new (Context) CaseStmt(Empty);
3089 break;
3090
3091 case STMT_DEFAULT:
3092 S = new (Context) DefaultStmt(Empty);
3093 break;
3094
3095 case STMT_LABEL:
3096 S = new (Context) LabelStmt(Empty);
3097 break;
3098
3099 case STMT_ATTRIBUTED:
3100 S = AttributedStmt::CreateEmpty(
3101 Context,
3102 /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
3103 break;
3104
3105 case STMT_IF:
3106 S = new (Context) IfStmt(Empty);
3107 break;
3108
3109 case STMT_SWITCH:
3110 S = new (Context) SwitchStmt(Empty);
3111 break;
3112
3113 case STMT_WHILE:
3114 S = new (Context) WhileStmt(Empty);
3115 break;
3116
3117 case STMT_DO:
3118 S = new (Context) DoStmt(Empty);
3119 break;
3120
3121 case STMT_FOR:
3122 S = new (Context) ForStmt(Empty);
3123 break;
3124
3125 case STMT_GOTO:
3126 S = new (Context) GotoStmt(Empty);
3127 break;
3128
3129 case STMT_INDIRECT_GOTO:
3130 S = new (Context) IndirectGotoStmt(Empty);
3131 break;
3132
3133 case STMT_CONTINUE:
3134 S = new (Context) ContinueStmt(Empty);
3135 break;
3136
3137 case STMT_BREAK:
3138 S = new (Context) BreakStmt(Empty);
3139 break;
3140
3141 case STMT_RETURN:
3142 S = new (Context) ReturnStmt(Empty);
3143 break;
3144
3145 case STMT_DECL:
3146 S = new (Context) DeclStmt(Empty);
3147 break;
3148
3149 case STMT_GCCASM:
3150 S = new (Context) GCCAsmStmt(Empty);
3151 break;
3152
3153 case STMT_MSASM:
3154 S = new (Context) MSAsmStmt(Empty);
3155 break;
3156
3157 case STMT_CAPTURED:
3158 S = CapturedStmt::CreateDeserialized(Context,
3159 Record[ASTStmtReader::NumStmtFields]);
3160 break;
3161
3162 case EXPR_PREDEFINED:
3163 S = new (Context) PredefinedExpr(Empty);
3164 break;
3165
3166 case EXPR_DECL_REF:
3167 S = DeclRefExpr::CreateEmpty(
3168 Context,
3169 /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
3170 /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
3171 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
3172 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
3173 Record[ASTStmtReader::NumExprFields + 5] : 0);
3174 break;
3175
3176 case EXPR_INTEGER_LITERAL:
3177 S = IntegerLiteral::Create(Context, Empty);
3178 break;
3179
3180 case EXPR_FLOATING_LITERAL:
3181 S = FloatingLiteral::Create(Context, Empty);
3182 break;
3183
3184 case EXPR_IMAGINARY_LITERAL:
3185 S = new (Context) ImaginaryLiteral(Empty);
3186 break;
3187
3188 case EXPR_STRING_LITERAL:
3189 S = StringLiteral::CreateEmpty(Context,
3190 Record[ASTStmtReader::NumExprFields + 1]);
3191 break;
3192
3193 case EXPR_CHARACTER_LITERAL:
3194 S = new (Context) CharacterLiteral(Empty);
3195 break;
3196
3197 case EXPR_PAREN:
3198 S = new (Context) ParenExpr(Empty);
3199 break;
3200
3201 case EXPR_PAREN_LIST:
3202 S = new (Context) ParenListExpr(Empty);
3203 break;
3204
3205 case EXPR_UNARY_OPERATOR:
3206 S = new (Context) UnaryOperator(Empty);
3207 break;
3208
3209 case EXPR_OFFSETOF:
3210 S = OffsetOfExpr::CreateEmpty(Context,
3211 Record[ASTStmtReader::NumExprFields],
3212 Record[ASTStmtReader::NumExprFields + 1]);
3213 break;
3214
3215 case EXPR_SIZEOF_ALIGN_OF:
3216 S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
3217 break;
3218
3219 case EXPR_ARRAY_SUBSCRIPT:
3220 S = new (Context) ArraySubscriptExpr(Empty);
3221 break;
3222
3223 case EXPR_OMP_ARRAY_SECTION:
3224 S = new (Context) OMPArraySectionExpr(Empty);
3225 break;
3226
3227 case EXPR_CALL:
3228 S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
3229 break;
3230
3231 case EXPR_MEMBER: {
3232 // We load everything here and fully initialize it at creation.
3233 // That way we can use MemberExpr::Create and don't have to duplicate its
3234 // logic with a MemberExpr::CreateEmpty.
3235
3236 assert(Record.getIdx() == 0)(static_cast <bool> (Record.getIdx() == 0) ? void (0) :
__assert_fail ("Record.getIdx() == 0", "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3236, __extension__ __PRETTY_FUNCTION__))
;
3237 NestedNameSpecifierLoc QualifierLoc;
3238 if (Record.readInt()) { // HasQualifier.
3239 QualifierLoc = Record.readNestedNameSpecifierLoc();
3240 }
3241
3242 SourceLocation TemplateKWLoc;
3243 TemplateArgumentListInfo ArgInfo;
3244 bool HasTemplateKWAndArgsInfo = Record.readInt();
3245 if (HasTemplateKWAndArgsInfo) {
3246 TemplateKWLoc = Record.readSourceLocation();
3247 unsigned NumTemplateArgs = Record.readInt();
3248 ArgInfo.setLAngleLoc(Record.readSourceLocation());
3249 ArgInfo.setRAngleLoc(Record.readSourceLocation());
3250 for (unsigned i = 0; i != NumTemplateArgs; ++i)
3251 ArgInfo.addArgument(Record.readTemplateArgumentLoc());
3252 }
3253
3254 bool HadMultipleCandidates = Record.readInt();
3255
3256 NamedDecl *FoundD = Record.readDeclAs<NamedDecl>();
3257 AccessSpecifier AS = (AccessSpecifier)Record.readInt();
3258 DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
3259
3260 QualType T = Record.readType();
3261 ExprValueKind VK = static_cast<ExprValueKind>(Record.readInt());
3262 ExprObjectKind OK = static_cast<ExprObjectKind>(Record.readInt());
3263 Expr *Base = ReadSubExpr();
3264 ValueDecl *MemberD = Record.readDeclAs<ValueDecl>();
3265 SourceLocation MemberLoc = Record.readSourceLocation();
3266 DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
3267 bool IsArrow = Record.readInt();
3268 SourceLocation OperatorLoc = Record.readSourceLocation();
3269
3270 S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,
3271 TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
3272 HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,
3273 VK, OK);
3274 Record.readDeclarationNameLoc(cast<MemberExpr>(S)->MemberDNLoc,
3275 MemberD->getDeclName());
3276 if (HadMultipleCandidates)
3277 cast<MemberExpr>(S)->setHadMultipleCandidates(true);
3278 break;
3279 }
3280
3281 case EXPR_BINARY_OPERATOR:
3282 S = new (Context) BinaryOperator(Empty);
3283 break;
3284
3285 case EXPR_COMPOUND_ASSIGN_OPERATOR:
3286 S = new (Context) CompoundAssignOperator(Empty);
3287 break;
3288
3289 case EXPR_CONDITIONAL_OPERATOR:
3290 S = new (Context) ConditionalOperator(Empty);
3291 break;
3292
3293 case EXPR_BINARY_CONDITIONAL_OPERATOR:
3294 S = new (Context) BinaryConditionalOperator(Empty);
3295 break;
3296
3297 case EXPR_IMPLICIT_CAST:
3298 S = ImplicitCastExpr::CreateEmpty(Context,
3299 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3300 break;
3301
3302 case EXPR_CSTYLE_CAST:
3303 S = CStyleCastExpr::CreateEmpty(Context,
3304 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3305 break;
3306
3307 case EXPR_COMPOUND_LITERAL:
3308 S = new (Context) CompoundLiteralExpr(Empty);
3309 break;
3310
3311 case EXPR_EXT_VECTOR_ELEMENT:
3312 S = new (Context) ExtVectorElementExpr(Empty);
3313 break;
3314
3315 case EXPR_INIT_LIST:
3316 S = new (Context) InitListExpr(Empty);
3317 break;
3318
3319 case EXPR_DESIGNATED_INIT:
3320 S = DesignatedInitExpr::CreateEmpty(Context,
3321 Record[ASTStmtReader::NumExprFields] - 1);
3322
3323 break;
3324
3325 case EXPR_DESIGNATED_INIT_UPDATE:
3326 S = new (Context) DesignatedInitUpdateExpr(Empty);
3327 break;
3328
3329 case EXPR_IMPLICIT_VALUE_INIT:
3330 S = new (Context) ImplicitValueInitExpr(Empty);
3331 break;
3332
3333 case EXPR_NO_INIT:
3334 S = new (Context) NoInitExpr(Empty);
3335 break;
3336
3337 case EXPR_ARRAY_INIT_LOOP:
3338 S = new (Context) ArrayInitLoopExpr(Empty);
3339 break;
3340
3341 case EXPR_ARRAY_INIT_INDEX:
3342 S = new (Context) ArrayInitIndexExpr(Empty);
3343 break;
3344
3345 case EXPR_VA_ARG:
3346 S = new (Context) VAArgExpr(Empty);
3347 break;
3348
3349 case EXPR_ADDR_LABEL:
3350 S = new (Context) AddrLabelExpr(Empty);
3351 break;
3352
3353 case EXPR_STMT:
3354 S = new (Context) StmtExpr(Empty);
3355 break;
3356
3357 case EXPR_CHOOSE:
3358 S = new (Context) ChooseExpr(Empty);
3359 break;
3360
3361 case EXPR_GNU_NULL:
3362 S = new (Context) GNUNullExpr(Empty);
3363 break;
3364
3365 case EXPR_SHUFFLE_VECTOR:
3366 S = new (Context) ShuffleVectorExpr(Empty);
3367 break;
3368
3369 case EXPR_CONVERT_VECTOR:
3370 S = new (Context) ConvertVectorExpr(Empty);
3371 break;
3372
3373 case EXPR_BLOCK:
3374 S = new (Context) BlockExpr(Empty);
3375 break;
3376
3377 case EXPR_GENERIC_SELECTION:
3378 S = new (Context) GenericSelectionExpr(Empty);
3379 break;
3380
3381 case EXPR_OBJC_STRING_LITERAL:
3382 S = new (Context) ObjCStringLiteral(Empty);
3383 break;
3384 case EXPR_OBJC_BOXED_EXPRESSION:
3385 S = new (Context) ObjCBoxedExpr(Empty);
3386 break;
3387 case EXPR_OBJC_ARRAY_LITERAL:
3388 S = ObjCArrayLiteral::CreateEmpty(Context,
3389 Record[ASTStmtReader::NumExprFields]);
3390 break;
3391 case EXPR_OBJC_DICTIONARY_LITERAL:
3392 S = ObjCDictionaryLiteral::CreateEmpty(Context,
3393 Record[ASTStmtReader::NumExprFields],
3394 Record[ASTStmtReader::NumExprFields + 1]);
3395 break;
3396 case EXPR_OBJC_ENCODE:
3397 S = new (Context) ObjCEncodeExpr(Empty);
3398 break;
3399 case EXPR_OBJC_SELECTOR_EXPR:
3400 S = new (Context) ObjCSelectorExpr(Empty);
3401 break;
3402 case EXPR_OBJC_PROTOCOL_EXPR:
3403 S = new (Context) ObjCProtocolExpr(Empty);
3404 break;
3405 case EXPR_OBJC_IVAR_REF_EXPR:
3406 S = new (Context) ObjCIvarRefExpr(Empty);
3407 break;
3408 case EXPR_OBJC_PROPERTY_REF_EXPR:
3409 S = new (Context) ObjCPropertyRefExpr(Empty);
3410 break;
3411 case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
3412 S = new (Context) ObjCSubscriptRefExpr(Empty);
3413 break;
3414 case EXPR_OBJC_KVC_REF_EXPR:
3415 llvm_unreachable("mismatching AST file")::llvm::llvm_unreachable_internal("mismatching AST file", "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3415)
;
3416 case EXPR_OBJC_MESSAGE_EXPR:
3417 S = ObjCMessageExpr::CreateEmpty(Context,
3418 Record[ASTStmtReader::NumExprFields],
3419 Record[ASTStmtReader::NumExprFields + 1]);
3420 break;
3421 case EXPR_OBJC_ISA:
3422 S = new (Context) ObjCIsaExpr(Empty);
3423 break;
3424 case EXPR_OBJC_INDIRECT_COPY_RESTORE:
3425 S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3426 break;
3427 case EXPR_OBJC_BRIDGED_CAST:
3428 S = new (Context) ObjCBridgedCastExpr(Empty);
3429 break;
3430 case STMT_OBJC_FOR_COLLECTION:
3431 S = new (Context) ObjCForCollectionStmt(Empty);
3432 break;
3433 case STMT_OBJC_CATCH:
3434 S = new (Context) ObjCAtCatchStmt(Empty);
3435 break;
3436 case STMT_OBJC_FINALLY:
3437 S = new (Context) ObjCAtFinallyStmt(Empty);
3438 break;
3439 case STMT_OBJC_AT_TRY:
3440 S = ObjCAtTryStmt::CreateEmpty(Context,
3441 Record[ASTStmtReader::NumStmtFields],
3442 Record[ASTStmtReader::NumStmtFields + 1]);
3443 break;
3444 case STMT_OBJC_AT_SYNCHRONIZED:
3445 S = new (Context) ObjCAtSynchronizedStmt(Empty);
3446 break;
3447 case STMT_OBJC_AT_THROW:
3448 S = new (Context) ObjCAtThrowStmt(Empty);
3449 break;
3450 case STMT_OBJC_AUTORELEASE_POOL:
3451 S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3452 break;
3453 case EXPR_OBJC_BOOL_LITERAL:
3454 S = new (Context) ObjCBoolLiteralExpr(Empty);
3455 break;
3456 case EXPR_OBJC_AVAILABILITY_CHECK:
3457 S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3458 break;
3459 case STMT_SEH_LEAVE:
3460 S = new (Context) SEHLeaveStmt(Empty);
3461 break;
3462 case STMT_SEH_EXCEPT:
3463 S = new (Context) SEHExceptStmt(Empty);
3464 break;
3465 case STMT_SEH_FINALLY:
3466 S = new (Context) SEHFinallyStmt(Empty);
3467 break;
3468 case STMT_SEH_TRY:
3469 S = new (Context) SEHTryStmt(Empty);
3470 break;
3471 case STMT_CXX_CATCH:
3472 S = new (Context) CXXCatchStmt(Empty);
3473 break;
3474
3475 case STMT_CXX_TRY:
3476 S = CXXTryStmt::Create(Context, Empty,
3477 /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3478 break;
3479
3480 case STMT_CXX_FOR_RANGE:
3481 S = new (Context) CXXForRangeStmt(Empty);
3482 break;
3483
3484 case STMT_MS_DEPENDENT_EXISTS:
3485 S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3486 NestedNameSpecifierLoc(),
3487 DeclarationNameInfo(),
3488 nullptr);
3489 break;
3490
3491 case STMT_OMP_PARALLEL_DIRECTIVE:
3492 S =
3493 OMPParallelDirective::CreateEmpty(Context,
3494 Record[ASTStmtReader::NumStmtFields],
3495 Empty);
3496 break;
3497
3498 case STMT_OMP_SIMD_DIRECTIVE: {
3499 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3500 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3501 S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
3502 CollapsedNum, Empty);
3503 break;
3504 }
3505
3506 case STMT_OMP_FOR_DIRECTIVE: {
3507 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3508 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3509 S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3510 Empty);
3511 break;
3512 }
3513
3514 case STMT_OMP_FOR_SIMD_DIRECTIVE: {
3515 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3516 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3517 S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3518 Empty);
3519 break;
3520 }
3521
3522 case STMT_OMP_SECTIONS_DIRECTIVE:
3523 S = OMPSectionsDirective::CreateEmpty(
3524 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3525 break;
3526
3527 case STMT_OMP_SECTION_DIRECTIVE:
3528 S = OMPSectionDirective::CreateEmpty(Context, Empty);
3529 break;
3530
3531 case STMT_OMP_SINGLE_DIRECTIVE:
3532 S = OMPSingleDirective::CreateEmpty(
3533 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3534 break;
3535
3536 case STMT_OMP_MASTER_DIRECTIVE:
3537 S = OMPMasterDirective::CreateEmpty(Context, Empty);
3538 break;
3539
3540 case STMT_OMP_CRITICAL_DIRECTIVE:
3541 S = OMPCriticalDirective::CreateEmpty(
3542 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3543 break;
3544
3545 case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
3546 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3547 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3548 S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
3549 CollapsedNum, Empty);
3550 break;
3551 }
3552
3553 case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
3554 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3555 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3556 S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3557 CollapsedNum, Empty);
3558 break;
3559 }
3560
3561 case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
3562 S = OMPParallelSectionsDirective::CreateEmpty(
3563 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3564 break;
3565
3566 case STMT_OMP_TASK_DIRECTIVE:
3567 S = OMPTaskDirective::CreateEmpty(
3568 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3569 break;
3570
3571 case STMT_OMP_TASKYIELD_DIRECTIVE:
3572 S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
3573 break;
3574
3575 case STMT_OMP_BARRIER_DIRECTIVE:
3576 S = OMPBarrierDirective::CreateEmpty(Context, Empty);
3577 break;
3578
3579 case STMT_OMP_TASKWAIT_DIRECTIVE:
3580 S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
3581 break;
3582
3583 case STMT_OMP_TASKGROUP_DIRECTIVE:
3584 S = OMPTaskgroupDirective::CreateEmpty(
3585 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3586 break;
3587
3588 case STMT_OMP_FLUSH_DIRECTIVE:
3589 S = OMPFlushDirective::CreateEmpty(
3590 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3591 break;
3592
3593 case STMT_OMP_ORDERED_DIRECTIVE:
3594 S = OMPOrderedDirective::CreateEmpty(
3595 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3596 break;
3597
3598 case STMT_OMP_ATOMIC_DIRECTIVE:
3599 S = OMPAtomicDirective::CreateEmpty(
3600 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3601 break;
3602
3603 case STMT_OMP_TARGET_DIRECTIVE:
3604 S = OMPTargetDirective::CreateEmpty(
3605 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3606 break;
3607
3608 case STMT_OMP_TARGET_DATA_DIRECTIVE:
3609 S = OMPTargetDataDirective::CreateEmpty(
3610 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3611 break;
3612
3613 case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE:
3614 S = OMPTargetEnterDataDirective::CreateEmpty(
3615 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3616 break;
3617
3618 case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE:
3619 S = OMPTargetExitDataDirective::CreateEmpty(
3620 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3621 break;
3622
3623 case STMT_OMP_TARGET_PARALLEL_DIRECTIVE:
3624 S = OMPTargetParallelDirective::CreateEmpty(
3625 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3626 break;
3627
3628 case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: {
3629 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3630 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3631 S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
3632 CollapsedNum, Empty);
3633 break;
3634 }
3635
3636 case STMT_OMP_TARGET_UPDATE_DIRECTIVE:
3637 S = OMPTargetUpdateDirective::CreateEmpty(
3638 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3639 break;
3640
3641 case STMT_OMP_TEAMS_DIRECTIVE:
3642 S = OMPTeamsDirective::CreateEmpty(
3643 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3644 break;
3645
3646 case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
3647 S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3648 break;
3649
3650 case STMT_OMP_CANCEL_DIRECTIVE:
3651 S = OMPCancelDirective::CreateEmpty(
3652 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3653 break;
3654
3655 case STMT_OMP_TASKLOOP_DIRECTIVE: {
3656 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3657 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3658 S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3659 Empty);
3660 break;
3661 }
3662
3663 case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
3664 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3665 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3666 S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3667 CollapsedNum, Empty);
3668 break;
3669 }
3670
3671 case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
3672 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3673 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3674 S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3675 Empty);
3676 break;
3677 }
3678
3679 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3680 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3681 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3682 S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
3683 CollapsedNum, Empty);
3684 break;
3685 }
3686
3687 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3688 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3689 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3690 S = OMPDistributeParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3691 CollapsedNum,
3692 Empty);
3693 break;
3694 }
3695
3696 case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: {
3697 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3698 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3699 S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3700 CollapsedNum, Empty);
3701 break;
3702 }
3703
3704 case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: {
3705 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3706 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3707 S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3708 CollapsedNum, Empty);
3709 break;
3710 }
3711
3712 case STMT_OMP_TARGET_SIMD_DIRECTIVE: {
3713 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3714 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3715 S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3716 Empty);
3717 break;
3718 }
3719
3720 case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: {
3721 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3722 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3723 S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3724 CollapsedNum, Empty);
3725 break;
3726 }
3727
3728 case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3729 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3730 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3731 S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3732 CollapsedNum, Empty);
3733 break;
3734 }
3735
3736 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3737 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3738 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3739 S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(
3740 Context, NumClauses, CollapsedNum, Empty);
3741 break;
3742 }
3743
3744 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3745 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3746 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3747 S = OMPTeamsDistributeParallelForDirective::CreateEmpty(
3748 Context, NumClauses, CollapsedNum, Empty);
3749 break;
3750 }
3751
3752 case STMT_OMP_TARGET_TEAMS_DIRECTIVE: {
3753 S = OMPTargetTeamsDirective::CreateEmpty(
3754 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3755 break;
3756 }
3757
3758 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: {
3759 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3760 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3761 S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3762 CollapsedNum, Empty);
3763 break;
3764 }
3765
3766 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3767 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3768 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3769 S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(
3770 Context, NumClauses, CollapsedNum, Empty);
3771 break;
3772 }
3773
3774 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3775 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3776 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3777 S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
3778 Context, NumClauses, CollapsedNum, Empty);
3779 break;
3780 }
3781
3782 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3783 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3784 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3785 S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty(
3786 Context, NumClauses, CollapsedNum, Empty);
3787 break;
3788 }
3789
3790 case EXPR_CXX_OPERATOR_CALL:
3791 S = new (Context) CXXOperatorCallExpr(Context, Empty);
3792 break;
3793
3794 case EXPR_CXX_MEMBER_CALL:
3795 S = new (Context) CXXMemberCallExpr(Context, Empty);
3796 break;
3797
3798 case EXPR_CXX_CONSTRUCT:
3799 S = new (Context) CXXConstructExpr(Empty);
3800 break;
3801
3802 case EXPR_CXX_INHERITED_CTOR_INIT:
3803 S = new (Context) CXXInheritedCtorInitExpr(Empty);
3804 break;
3805
3806 case EXPR_CXX_TEMPORARY_OBJECT:
3807 S = new (Context) CXXTemporaryObjectExpr(Empty);
3808 break;
3809
3810 case EXPR_CXX_STATIC_CAST:
3811 S = CXXStaticCastExpr::CreateEmpty(Context,
3812 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3813 break;
3814
3815 case EXPR_CXX_DYNAMIC_CAST:
3816 S = CXXDynamicCastExpr::CreateEmpty(Context,
3817 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3818 break;
3819
3820 case EXPR_CXX_REINTERPRET_CAST:
3821 S = CXXReinterpretCastExpr::CreateEmpty(Context,
3822 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3823 break;
3824
3825 case EXPR_CXX_CONST_CAST:
3826 S = CXXConstCastExpr::CreateEmpty(Context);
3827 break;
3828
3829 case EXPR_CXX_FUNCTIONAL_CAST:
3830 S = CXXFunctionalCastExpr::CreateEmpty(Context,
3831 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3832 break;
3833
3834 case EXPR_USER_DEFINED_LITERAL:
3835 S = new (Context) UserDefinedLiteral(Context, Empty);
3836 break;
3837
3838 case EXPR_CXX_STD_INITIALIZER_LIST:
3839 S = new (Context) CXXStdInitializerListExpr(Empty);
3840 break;
3841
3842 case EXPR_CXX_BOOL_LITERAL:
3843 S = new (Context) CXXBoolLiteralExpr(Empty);
3844 break;
3845
3846 case EXPR_CXX_NULL_PTR_LITERAL:
3847 S = new (Context) CXXNullPtrLiteralExpr(Empty);
3848 break;
3849 case EXPR_CXX_TYPEID_EXPR:
3850 S = new (Context) CXXTypeidExpr(Empty, true);
3851 break;
3852 case EXPR_CXX_TYPEID_TYPE:
3853 S = new (Context) CXXTypeidExpr(Empty, false);
3854 break;
3855 case EXPR_CXX_UUIDOF_EXPR:
3856 S = new (Context) CXXUuidofExpr(Empty, true);
3857 break;
3858 case EXPR_CXX_PROPERTY_REF_EXPR:
3859 S = new (Context) MSPropertyRefExpr(Empty);
3860 break;
3861 case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
3862 S = new (Context) MSPropertySubscriptExpr(Empty);
3863 break;
3864 case EXPR_CXX_UUIDOF_TYPE:
3865 S = new (Context) CXXUuidofExpr(Empty, false);
3866 break;
3867 case EXPR_CXX_THIS:
3868 S = new (Context) CXXThisExpr(Empty);
3869 break;
3870 case EXPR_CXX_THROW:
3871 S = new (Context) CXXThrowExpr(Empty);
3872 break;
3873 case EXPR_CXX_DEFAULT_ARG:
3874 S = new (Context) CXXDefaultArgExpr(Empty);
3875 break;
3876 case EXPR_CXX_DEFAULT_INIT:
3877 S = new (Context) CXXDefaultInitExpr(Empty);
3878 break;
3879 case EXPR_CXX_BIND_TEMPORARY:
3880 S = new (Context) CXXBindTemporaryExpr(Empty);
3881 break;
3882
3883 case EXPR_CXX_SCALAR_VALUE_INIT:
3884 S = new (Context) CXXScalarValueInitExpr(Empty);
3885 break;
3886 case EXPR_CXX_NEW:
3887 S = new (Context) CXXNewExpr(Empty);
3888 break;
3889 case EXPR_CXX_DELETE:
3890 S = new (Context) CXXDeleteExpr(Empty);
3891 break;
3892 case EXPR_CXX_PSEUDO_DESTRUCTOR:
3893 S = new (Context) CXXPseudoDestructorExpr(Empty);
3894 break;
3895
3896 case EXPR_EXPR_WITH_CLEANUPS:
3897 S = ExprWithCleanups::Create(Context, Empty,
3898 Record[ASTStmtReader::NumExprFields]);
3899 break;
3900
3901 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
3902 S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
3903 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3904 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3905 ? Record[ASTStmtReader::NumExprFields + 1]
3906 : 0);
3907 break;
3908
3909 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
3910 S = DependentScopeDeclRefExpr::CreateEmpty(Context,
3911 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3912 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3913 ? Record[ASTStmtReader::NumExprFields + 1]
3914 : 0);
3915 break;
3916
3917 case EXPR_CXX_UNRESOLVED_CONSTRUCT:
3918 S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
3919 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3920 break;
3921
3922 case EXPR_CXX_UNRESOLVED_MEMBER:
3923 S = UnresolvedMemberExpr::CreateEmpty(Context,
3924 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3925 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3926 ? Record[ASTStmtReader::NumExprFields + 1]
3927 : 0);
3928 break;
3929
3930 case EXPR_CXX_UNRESOLVED_LOOKUP:
3931 S = UnresolvedLookupExpr::CreateEmpty(Context,
3932 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3933 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3934 ? Record[ASTStmtReader::NumExprFields + 1]
3935 : 0);
3936 break;
3937
3938 case EXPR_TYPE_TRAIT:
3939 S = TypeTraitExpr::CreateDeserialized(Context,
3940 Record[ASTStmtReader::NumExprFields]);
3941 break;
3942
3943 case EXPR_ARRAY_TYPE_TRAIT:
3944 S = new (Context) ArrayTypeTraitExpr(Empty);
3945 break;
3946
3947 case EXPR_CXX_EXPRESSION_TRAIT:
3948 S = new (Context) ExpressionTraitExpr(Empty);
3949 break;
3950
3951 case EXPR_CXX_NOEXCEPT:
3952 S = new (Context) CXXNoexceptExpr(Empty);
3953 break;
3954
3955 case EXPR_PACK_EXPANSION:
3956 S = new (Context) PackExpansionExpr(Empty);
3957 break;
3958
3959 case EXPR_SIZEOF_PACK:
3960 S = SizeOfPackExpr::CreateDeserialized(
3961 Context,
3962 /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3963 break;
3964
3965 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
3966 S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3967 break;
3968
3969 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
3970 S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3971 break;
3972
3973 case EXPR_FUNCTION_PARM_PACK:
3974 S = FunctionParmPackExpr::CreateEmpty(Context,
3975 Record[ASTStmtReader::NumExprFields]);
3976 break;
3977
3978 case EXPR_MATERIALIZE_TEMPORARY:
3979 S = new (Context) MaterializeTemporaryExpr(Empty);
3980 break;
3981
3982 case EXPR_CXX_FOLD:
3983 S = new (Context) CXXFoldExpr(Empty);
3984 break;
3985
3986 case EXPR_OPAQUE_VALUE:
3987 S = new (Context) OpaqueValueExpr(Empty);
3988 break;
3989
3990 case EXPR_CUDA_KERNEL_CALL:
3991 S = new (Context) CUDAKernelCallExpr(Context, Empty);
3992 break;
3993
3994 case EXPR_ASTYPE:
3995 S = new (Context) AsTypeExpr(Empty);
3996 break;
3997
3998 case EXPR_PSEUDO_OBJECT: {
3999 unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
4000 S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
4001 break;
4002 }
4003
4004 case EXPR_ATOMIC:
4005 S = new (Context) AtomicExpr(Empty);
4006 break;
4007
4008 case EXPR_LAMBDA: {
4009 unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
4010 S = LambdaExpr::CreateDeserialized(Context, NumCaptures);
4011 break;
4012 }
4013
4014 case STMT_COROUTINE_BODY: {
4015 unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
4016 S = CoroutineBodyStmt::Create(Context, Empty, NumParams);
4017 break;
4018 }
4019
4020 case STMT_CORETURN:
4021 S = new (Context) CoreturnStmt(Empty);
4022 break;
4023
4024 case EXPR_COAWAIT:
4025 S = new (Context) CoawaitExpr(Empty);
4026 break;
4027
4028 case EXPR_COYIELD:
4029 S = new (Context) CoyieldExpr(Empty);
4030 break;
4031
4032 case EXPR_DEPENDENT_COAWAIT:
4033 S = new (Context) DependentCoawaitExpr(Empty);
4034 break;
4035
4036 }
4037
4038 // We hit a STMT_STOP, so we're done with this expression.
4039 if (Finished)
4040 break;
4041
4042 ++NumStatementsRead;
4043
4044 if (S && !IsStmtReference) {
4045 Reader.Visit(S);
4046 StmtEntries[Cursor.GetCurrentBitNo()] = S;
4047 }
4048
4049 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~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 4050, __extension__ __PRETTY_FUNCTION__))
4050 "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~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 4050, __extension__ __PRETTY_FUNCTION__))
;
4051 StmtStack.push_back(S);
4052 }
4053Done:
4054 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~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 4054, __extension__ __PRETTY_FUNCTION__))
;
4055 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~svn318882/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 4055, __extension__ __PRETTY_FUNCTION__))
;
4056 return StmtStack.pop_back_val();
4057}

/build/llvm-toolchain-snapshot-6.0~svn318882/include/llvm/Bitcode/BitstreamReader.h

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