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