1 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// Implements serialization for Statements and Expressions.
11 ///
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/ExprOpenMP.h"
15 #include "clang/Serialization/ASTRecordWriter.h"
16 #include "clang/Sema/DeclSpec.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/DeclTemplate.h"
21 #include "clang/AST/StmtVisitor.h"
22 #include "clang/Lex/Token.h"
23 #include "llvm/Bitstream/BitstreamWriter.h"
24 using namespace clang;
25
26 //===----------------------------------------------------------------------===//
27 // Statement/expression serialization
28 //===----------------------------------------------------------------------===//
29
30 namespace clang {
31
32 class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
33 ASTWriter &Writer;
34 ASTRecordWriter Record;
35
36 serialization::StmtCode Code;
37 unsigned AbbrevToUse;
38
39 public:
ASTStmtWriter(ASTWriter & Writer,ASTWriter::RecordData & Record)40 ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
41 : Writer(Writer), Record(Writer, Record),
42 Code(serialization::STMT_NULL_PTR), AbbrevToUse(0) {}
43
44 ASTStmtWriter(const ASTStmtWriter&) = delete;
45
Emit()46 uint64_t Emit() {
47 assert(Code != serialization::STMT_NULL_PTR &&
48 "unhandled sub-statement writing AST file");
49 return Record.EmitStmt(Code, AbbrevToUse);
50 }
51
52 void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo,
53 const TemplateArgumentLoc *Args);
54
55 void VisitStmt(Stmt *S);
56 #define STMT(Type, Base) \
57 void Visit##Type(Type *);
58 #include "clang/AST/StmtNodes.inc"
59 };
60 }
61
AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo & ArgInfo,const TemplateArgumentLoc * Args)62 void ASTStmtWriter::AddTemplateKWAndArgsInfo(
63 const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) {
64 Record.AddSourceLocation(ArgInfo.TemplateKWLoc);
65 Record.AddSourceLocation(ArgInfo.LAngleLoc);
66 Record.AddSourceLocation(ArgInfo.RAngleLoc);
67 for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i)
68 Record.AddTemplateArgumentLoc(Args[i]);
69 }
70
VisitStmt(Stmt * S)71 void ASTStmtWriter::VisitStmt(Stmt *S) {
72 }
73
VisitNullStmt(NullStmt * S)74 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
75 VisitStmt(S);
76 Record.AddSourceLocation(S->getSemiLoc());
77 Record.push_back(S->NullStmtBits.HasLeadingEmptyMacro);
78 Code = serialization::STMT_NULL;
79 }
80
VisitCompoundStmt(CompoundStmt * S)81 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
82 VisitStmt(S);
83 Record.push_back(S->size());
84 for (auto *CS : S->body())
85 Record.AddStmt(CS);
86 Record.AddSourceLocation(S->getLBracLoc());
87 Record.AddSourceLocation(S->getRBracLoc());
88 Code = serialization::STMT_COMPOUND;
89 }
90
VisitSwitchCase(SwitchCase * S)91 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
92 VisitStmt(S);
93 Record.push_back(Writer.getSwitchCaseID(S));
94 Record.AddSourceLocation(S->getKeywordLoc());
95 Record.AddSourceLocation(S->getColonLoc());
96 }
97
VisitCaseStmt(CaseStmt * S)98 void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
99 VisitSwitchCase(S);
100 Record.push_back(S->caseStmtIsGNURange());
101 Record.AddStmt(S->getLHS());
102 Record.AddStmt(S->getSubStmt());
103 if (S->caseStmtIsGNURange()) {
104 Record.AddStmt(S->getRHS());
105 Record.AddSourceLocation(S->getEllipsisLoc());
106 }
107 Code = serialization::STMT_CASE;
108 }
109
VisitDefaultStmt(DefaultStmt * S)110 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
111 VisitSwitchCase(S);
112 Record.AddStmt(S->getSubStmt());
113 Code = serialization::STMT_DEFAULT;
114 }
115
VisitLabelStmt(LabelStmt * S)116 void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
117 VisitStmt(S);
118 Record.AddDeclRef(S->getDecl());
119 Record.AddStmt(S->getSubStmt());
120 Record.AddSourceLocation(S->getIdentLoc());
121 Code = serialization::STMT_LABEL;
122 }
123
VisitAttributedStmt(AttributedStmt * S)124 void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {
125 VisitStmt(S);
126 Record.push_back(S->getAttrs().size());
127 Record.AddAttributes(S->getAttrs());
128 Record.AddStmt(S->getSubStmt());
129 Record.AddSourceLocation(S->getAttrLoc());
130 Code = serialization::STMT_ATTRIBUTED;
131 }
132
VisitIfStmt(IfStmt * S)133 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
134 VisitStmt(S);
135
136 bool HasElse = S->getElse() != nullptr;
137 bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
138 bool HasInit = S->getInit() != nullptr;
139
140 Record.push_back(S->isConstexpr());
141 Record.push_back(HasElse);
142 Record.push_back(HasVar);
143 Record.push_back(HasInit);
144
145 Record.AddStmt(S->getCond());
146 Record.AddStmt(S->getThen());
147 if (HasElse)
148 Record.AddStmt(S->getElse());
149 if (HasVar)
150 Record.AddDeclRef(S->getConditionVariable());
151 if (HasInit)
152 Record.AddStmt(S->getInit());
153
154 Record.AddSourceLocation(S->getIfLoc());
155 if (HasElse)
156 Record.AddSourceLocation(S->getElseLoc());
157
158 Code = serialization::STMT_IF;
159 }
160
VisitSwitchStmt(SwitchStmt * S)161 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
162 VisitStmt(S);
163
164 bool HasInit = S->getInit() != nullptr;
165 bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
166 Record.push_back(HasInit);
167 Record.push_back(HasVar);
168 Record.push_back(S->isAllEnumCasesCovered());
169
170 Record.AddStmt(S->getCond());
171 Record.AddStmt(S->getBody());
172 if (HasInit)
173 Record.AddStmt(S->getInit());
174 if (HasVar)
175 Record.AddDeclRef(S->getConditionVariable());
176
177 Record.AddSourceLocation(S->getSwitchLoc());
178
179 for (SwitchCase *SC = S->getSwitchCaseList(); SC;
180 SC = SC->getNextSwitchCase())
181 Record.push_back(Writer.RecordSwitchCaseID(SC));
182 Code = serialization::STMT_SWITCH;
183 }
184
VisitWhileStmt(WhileStmt * S)185 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
186 VisitStmt(S);
187
188 bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
189 Record.push_back(HasVar);
190
191 Record.AddStmt(S->getCond());
192 Record.AddStmt(S->getBody());
193 if (HasVar)
194 Record.AddDeclRef(S->getConditionVariable());
195
196 Record.AddSourceLocation(S->getWhileLoc());
197 Record.AddSourceLocation(S->getLParenLoc());
198 Record.AddSourceLocation(S->getRParenLoc());
199 Code = serialization::STMT_WHILE;
200 }
201
VisitDoStmt(DoStmt * S)202 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
203 VisitStmt(S);
204 Record.AddStmt(S->getCond());
205 Record.AddStmt(S->getBody());
206 Record.AddSourceLocation(S->getDoLoc());
207 Record.AddSourceLocation(S->getWhileLoc());
208 Record.AddSourceLocation(S->getRParenLoc());
209 Code = serialization::STMT_DO;
210 }
211
VisitForStmt(ForStmt * S)212 void ASTStmtWriter::VisitForStmt(ForStmt *S) {
213 VisitStmt(S);
214 Record.AddStmt(S->getInit());
215 Record.AddStmt(S->getCond());
216 Record.AddDeclRef(S->getConditionVariable());
217 Record.AddStmt(S->getInc());
218 Record.AddStmt(S->getBody());
219 Record.AddSourceLocation(S->getForLoc());
220 Record.AddSourceLocation(S->getLParenLoc());
221 Record.AddSourceLocation(S->getRParenLoc());
222 Code = serialization::STMT_FOR;
223 }
224
VisitGotoStmt(GotoStmt * S)225 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
226 VisitStmt(S);
227 Record.AddDeclRef(S->getLabel());
228 Record.AddSourceLocation(S->getGotoLoc());
229 Record.AddSourceLocation(S->getLabelLoc());
230 Code = serialization::STMT_GOTO;
231 }
232
VisitIndirectGotoStmt(IndirectGotoStmt * S)233 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
234 VisitStmt(S);
235 Record.AddSourceLocation(S->getGotoLoc());
236 Record.AddSourceLocation(S->getStarLoc());
237 Record.AddStmt(S->getTarget());
238 Code = serialization::STMT_INDIRECT_GOTO;
239 }
240
VisitContinueStmt(ContinueStmt * S)241 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
242 VisitStmt(S);
243 Record.AddSourceLocation(S->getContinueLoc());
244 Code = serialization::STMT_CONTINUE;
245 }
246
VisitBreakStmt(BreakStmt * S)247 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
248 VisitStmt(S);
249 Record.AddSourceLocation(S->getBreakLoc());
250 Code = serialization::STMT_BREAK;
251 }
252
VisitReturnStmt(ReturnStmt * S)253 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
254 VisitStmt(S);
255
256 bool HasNRVOCandidate = S->getNRVOCandidate() != nullptr;
257 Record.push_back(HasNRVOCandidate);
258
259 Record.AddStmt(S->getRetValue());
260 if (HasNRVOCandidate)
261 Record.AddDeclRef(S->getNRVOCandidate());
262
263 Record.AddSourceLocation(S->getReturnLoc());
264 Code = serialization::STMT_RETURN;
265 }
266
VisitDeclStmt(DeclStmt * S)267 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
268 VisitStmt(S);
269 Record.AddSourceLocation(S->getBeginLoc());
270 Record.AddSourceLocation(S->getEndLoc());
271 DeclGroupRef DG = S->getDeclGroup();
272 for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
273 Record.AddDeclRef(*D);
274 Code = serialization::STMT_DECL;
275 }
276
VisitAsmStmt(AsmStmt * S)277 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
278 VisitStmt(S);
279 Record.push_back(S->getNumOutputs());
280 Record.push_back(S->getNumInputs());
281 Record.push_back(S->getNumClobbers());
282 Record.AddSourceLocation(S->getAsmLoc());
283 Record.push_back(S->isVolatile());
284 Record.push_back(S->isSimple());
285 }
286
VisitGCCAsmStmt(GCCAsmStmt * S)287 void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) {
288 VisitAsmStmt(S);
289 Record.push_back(S->getNumLabels());
290 Record.AddSourceLocation(S->getRParenLoc());
291 Record.AddStmt(S->getAsmString());
292
293 // Outputs
294 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
295 Record.AddIdentifierRef(S->getOutputIdentifier(I));
296 Record.AddStmt(S->getOutputConstraintLiteral(I));
297 Record.AddStmt(S->getOutputExpr(I));
298 }
299
300 // Inputs
301 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
302 Record.AddIdentifierRef(S->getInputIdentifier(I));
303 Record.AddStmt(S->getInputConstraintLiteral(I));
304 Record.AddStmt(S->getInputExpr(I));
305 }
306
307 // Clobbers
308 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
309 Record.AddStmt(S->getClobberStringLiteral(I));
310
311 // Labels
312 for (auto *E : S->labels()) Record.AddStmt(E);
313
314 Code = serialization::STMT_GCCASM;
315 }
316
VisitMSAsmStmt(MSAsmStmt * S)317 void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {
318 VisitAsmStmt(S);
319 Record.AddSourceLocation(S->getLBraceLoc());
320 Record.AddSourceLocation(S->getEndLoc());
321 Record.push_back(S->getNumAsmToks());
322 Record.AddString(S->getAsmString());
323
324 // Tokens
325 for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) {
326 // FIXME: Move this to ASTRecordWriter?
327 Writer.AddToken(S->getAsmToks()[I], Record.getRecordData());
328 }
329
330 // Clobbers
331 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) {
332 Record.AddString(S->getClobber(I));
333 }
334
335 // Outputs
336 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
337 Record.AddStmt(S->getOutputExpr(I));
338 Record.AddString(S->getOutputConstraint(I));
339 }
340
341 // Inputs
342 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
343 Record.AddStmt(S->getInputExpr(I));
344 Record.AddString(S->getInputConstraint(I));
345 }
346
347 Code = serialization::STMT_MSASM;
348 }
349
VisitCoroutineBodyStmt(CoroutineBodyStmt * CoroStmt)350 void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *CoroStmt) {
351 VisitStmt(CoroStmt);
352 Record.push_back(CoroStmt->getParamMoves().size());
353 for (Stmt *S : CoroStmt->children())
354 Record.AddStmt(S);
355 Code = serialization::STMT_COROUTINE_BODY;
356 }
357
VisitCoreturnStmt(CoreturnStmt * S)358 void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) {
359 VisitStmt(S);
360 Record.AddSourceLocation(S->getKeywordLoc());
361 Record.AddStmt(S->getOperand());
362 Record.AddStmt(S->getPromiseCall());
363 Record.push_back(S->isImplicit());
364 Code = serialization::STMT_CORETURN;
365 }
366
VisitCoroutineSuspendExpr(CoroutineSuspendExpr * E)367 void ASTStmtWriter::VisitCoroutineSuspendExpr(CoroutineSuspendExpr *E) {
368 VisitExpr(E);
369 Record.AddSourceLocation(E->getKeywordLoc());
370 for (Stmt *S : E->children())
371 Record.AddStmt(S);
372 Record.AddStmt(E->getOpaqueValue());
373 }
374
VisitCoawaitExpr(CoawaitExpr * E)375 void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *E) {
376 VisitCoroutineSuspendExpr(E);
377 Record.push_back(E->isImplicit());
378 Code = serialization::EXPR_COAWAIT;
379 }
380
VisitCoyieldExpr(CoyieldExpr * E)381 void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *E) {
382 VisitCoroutineSuspendExpr(E);
383 Code = serialization::EXPR_COYIELD;
384 }
385
VisitDependentCoawaitExpr(DependentCoawaitExpr * E)386 void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
387 VisitExpr(E);
388 Record.AddSourceLocation(E->getKeywordLoc());
389 for (Stmt *S : E->children())
390 Record.AddStmt(S);
391 Code = serialization::EXPR_DEPENDENT_COAWAIT;
392 }
393
394 static void
addConstraintSatisfaction(ASTRecordWriter & Record,const ASTConstraintSatisfaction & Satisfaction)395 addConstraintSatisfaction(ASTRecordWriter &Record,
396 const ASTConstraintSatisfaction &Satisfaction) {
397 Record.push_back(Satisfaction.IsSatisfied);
398 if (!Satisfaction.IsSatisfied) {
399 Record.push_back(Satisfaction.NumRecords);
400 for (const auto &DetailRecord : Satisfaction) {
401 Record.AddStmt(const_cast<Expr *>(DetailRecord.first));
402 auto *E = DetailRecord.second.dyn_cast<Expr *>();
403 Record.push_back(E == nullptr);
404 if (E)
405 Record.AddStmt(E);
406 else {
407 auto *Diag = DetailRecord.second.get<std::pair<SourceLocation,
408 StringRef> *>();
409 Record.AddSourceLocation(Diag->first);
410 Record.AddString(Diag->second);
411 }
412 }
413 }
414 }
415
416 static void
addSubstitutionDiagnostic(ASTRecordWriter & Record,const concepts::Requirement::SubstitutionDiagnostic * D)417 addSubstitutionDiagnostic(
418 ASTRecordWriter &Record,
419 const concepts::Requirement::SubstitutionDiagnostic *D) {
420 Record.AddString(D->SubstitutedEntity);
421 Record.AddSourceLocation(D->DiagLoc);
422 Record.AddString(D->DiagMessage);
423 }
424
VisitConceptSpecializationExpr(ConceptSpecializationExpr * E)425 void ASTStmtWriter::VisitConceptSpecializationExpr(
426 ConceptSpecializationExpr *E) {
427 VisitExpr(E);
428 ArrayRef<TemplateArgument> TemplateArgs = E->getTemplateArguments();
429 Record.push_back(TemplateArgs.size());
430 Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc());
431 Record.AddSourceLocation(E->getTemplateKWLoc());
432 Record.AddDeclarationNameInfo(E->getConceptNameInfo());
433 Record.AddDeclRef(E->getNamedConcept());
434 Record.AddDeclRef(E->getFoundDecl());
435 Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten());
436 for (const TemplateArgument &Arg : TemplateArgs)
437 Record.AddTemplateArgument(Arg);
438 if (!E->isValueDependent())
439 addConstraintSatisfaction(Record, E->getSatisfaction());
440
441 Code = serialization::EXPR_CONCEPT_SPECIALIZATION;
442 }
443
VisitRequiresExpr(RequiresExpr * E)444 void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) {
445 VisitExpr(E);
446 Record.push_back(E->getLocalParameters().size());
447 Record.push_back(E->getRequirements().size());
448 Record.AddSourceLocation(E->RequiresExprBits.RequiresKWLoc);
449 Record.push_back(E->RequiresExprBits.IsSatisfied);
450 Record.AddDeclRef(E->getBody());
451 for (ParmVarDecl *P : E->getLocalParameters())
452 Record.AddDeclRef(P);
453 for (concepts::Requirement *R : E->getRequirements()) {
454 if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(R)) {
455 Record.push_back(concepts::Requirement::RK_Type);
456 Record.push_back(TypeReq->Status);
457 if (TypeReq->Status == concepts::TypeRequirement::SS_SubstitutionFailure)
458 addSubstitutionDiagnostic(Record, TypeReq->getSubstitutionDiagnostic());
459 else
460 Record.AddTypeSourceInfo(TypeReq->getType());
461 } else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(R)) {
462 Record.push_back(ExprReq->getKind());
463 Record.push_back(ExprReq->Status);
464 if (ExprReq->isExprSubstitutionFailure()) {
465 addSubstitutionDiagnostic(Record,
466 ExprReq->Value.get<concepts::Requirement::SubstitutionDiagnostic *>());
467 } else
468 Record.AddStmt(ExprReq->Value.get<Expr *>());
469 if (ExprReq->getKind() == concepts::Requirement::RK_Compound) {
470 Record.AddSourceLocation(ExprReq->NoexceptLoc);
471 const auto &RetReq = ExprReq->getReturnTypeRequirement();
472 if (RetReq.isSubstitutionFailure()) {
473 Record.push_back(2);
474 addSubstitutionDiagnostic(Record, RetReq.getSubstitutionDiagnostic());
475 } else if (RetReq.isTypeConstraint()) {
476 Record.push_back(1);
477 Record.AddTemplateParameterList(
478 RetReq.getTypeConstraintTemplateParameterList());
479 if (ExprReq->Status >=
480 concepts::ExprRequirement::SS_ConstraintsNotSatisfied)
481 Record.AddStmt(
482 ExprReq->getReturnTypeRequirementSubstitutedConstraintExpr());
483 } else {
484 assert(RetReq.isEmpty());
485 Record.push_back(0);
486 }
487 }
488 } else {
489 auto *NestedReq = cast<concepts::NestedRequirement>(R);
490 Record.push_back(concepts::Requirement::RK_Nested);
491 Record.push_back(NestedReq->isSubstitutionFailure());
492 if (NestedReq->isSubstitutionFailure()){
493 addSubstitutionDiagnostic(Record,
494 NestedReq->getSubstitutionDiagnostic());
495 } else {
496 Record.AddStmt(NestedReq->Value.get<Expr *>());
497 if (!NestedReq->isDependent())
498 addConstraintSatisfaction(Record, *NestedReq->Satisfaction);
499 }
500 }
501 }
502 Record.AddSourceLocation(E->getEndLoc());
503
504 Code = serialization::EXPR_REQUIRES;
505 }
506
507
VisitCapturedStmt(CapturedStmt * S)508 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
509 VisitStmt(S);
510 // NumCaptures
511 Record.push_back(std::distance(S->capture_begin(), S->capture_end()));
512
513 // CapturedDecl and captured region kind
514 Record.AddDeclRef(S->getCapturedDecl());
515 Record.push_back(S->getCapturedRegionKind());
516
517 Record.AddDeclRef(S->getCapturedRecordDecl());
518
519 // Capture inits
520 for (auto *I : S->capture_inits())
521 Record.AddStmt(I);
522
523 // Body
524 Record.AddStmt(S->getCapturedStmt());
525
526 // Captures
527 for (const auto &I : S->captures()) {
528 if (I.capturesThis() || I.capturesVariableArrayType())
529 Record.AddDeclRef(nullptr);
530 else
531 Record.AddDeclRef(I.getCapturedVar());
532 Record.push_back(I.getCaptureKind());
533 Record.AddSourceLocation(I.getLocation());
534 }
535
536 Code = serialization::STMT_CAPTURED;
537 }
538
VisitExpr(Expr * E)539 void ASTStmtWriter::VisitExpr(Expr *E) {
540 VisitStmt(E);
541 Record.AddTypeRef(E->getType());
542 Record.push_back(E->isTypeDependent());
543 Record.push_back(E->isValueDependent());
544 Record.push_back(E->isInstantiationDependent());
545 Record.push_back(E->containsUnexpandedParameterPack());
546 Record.push_back(E->containsErrors());
547 Record.push_back(E->getValueKind());
548 Record.push_back(E->getObjectKind());
549 }
550
VisitConstantExpr(ConstantExpr * E)551 void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) {
552 VisitExpr(E);
553 Record.push_back(E->ConstantExprBits.ResultKind);
554
555 Record.push_back(E->ConstantExprBits.APValueKind);
556 Record.push_back(E->ConstantExprBits.IsUnsigned);
557 Record.push_back(E->ConstantExprBits.BitWidth);
558 // HasCleanup not serialized since we can just query the APValue.
559 Record.push_back(E->ConstantExprBits.IsImmediateInvocation);
560
561 switch (E->ConstantExprBits.ResultKind) {
562 case ConstantExpr::RSK_None:
563 break;
564 case ConstantExpr::RSK_Int64:
565 Record.push_back(E->Int64Result());
566 break;
567 case ConstantExpr::RSK_APValue:
568 Record.AddAPValue(E->APValueResult());
569 break;
570 default:
571 llvm_unreachable("unexpected ResultKind!");
572 }
573
574 Record.AddStmt(E->getSubExpr());
575 Code = serialization::EXPR_CONSTANT;
576 }
577
VisitPredefinedExpr(PredefinedExpr * E)578 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
579 VisitExpr(E);
580
581 bool HasFunctionName = E->getFunctionName() != nullptr;
582 Record.push_back(HasFunctionName);
583 Record.push_back(E->getIdentKind()); // FIXME: stable encoding
584 Record.AddSourceLocation(E->getLocation());
585 if (HasFunctionName)
586 Record.AddStmt(E->getFunctionName());
587 Code = serialization::EXPR_PREDEFINED;
588 }
589
VisitDeclRefExpr(DeclRefExpr * E)590 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
591 VisitExpr(E);
592
593 Record.push_back(E->hasQualifier());
594 Record.push_back(E->getDecl() != E->getFoundDecl());
595 Record.push_back(E->hasTemplateKWAndArgsInfo());
596 Record.push_back(E->hadMultipleCandidates());
597 Record.push_back(E->refersToEnclosingVariableOrCapture());
598 Record.push_back(E->isNonOdrUse());
599
600 if (E->hasTemplateKWAndArgsInfo()) {
601 unsigned NumTemplateArgs = E->getNumTemplateArgs();
602 Record.push_back(NumTemplateArgs);
603 }
604
605 DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
606
607 if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
608 (E->getDecl() == E->getFoundDecl()) &&
609 nk == DeclarationName::Identifier &&
610 !E->refersToEnclosingVariableOrCapture() && !E->isNonOdrUse()) {
611 AbbrevToUse = Writer.getDeclRefExprAbbrev();
612 }
613
614 if (E->hasQualifier())
615 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
616
617 if (E->getDecl() != E->getFoundDecl())
618 Record.AddDeclRef(E->getFoundDecl());
619
620 if (E->hasTemplateKWAndArgsInfo())
621 AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
622 E->getTrailingObjects<TemplateArgumentLoc>());
623
624 Record.AddDeclRef(E->getDecl());
625 Record.AddSourceLocation(E->getLocation());
626 Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
627 Code = serialization::EXPR_DECL_REF;
628 }
629
VisitIntegerLiteral(IntegerLiteral * E)630 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
631 VisitExpr(E);
632 Record.AddSourceLocation(E->getLocation());
633 Record.AddAPInt(E->getValue());
634
635 if (E->getValue().getBitWidth() == 32) {
636 AbbrevToUse = Writer.getIntegerLiteralAbbrev();
637 }
638
639 Code = serialization::EXPR_INTEGER_LITERAL;
640 }
641
VisitFixedPointLiteral(FixedPointLiteral * E)642 void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) {
643 VisitExpr(E);
644 Record.AddSourceLocation(E->getLocation());
645 Record.push_back(E->getScale());
646 Record.AddAPInt(E->getValue());
647 Code = serialization::EXPR_FIXEDPOINT_LITERAL;
648 }
649
VisitFloatingLiteral(FloatingLiteral * E)650 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
651 VisitExpr(E);
652 Record.push_back(E->getRawSemantics());
653 Record.push_back(E->isExact());
654 Record.AddAPFloat(E->getValue());
655 Record.AddSourceLocation(E->getLocation());
656 Code = serialization::EXPR_FLOATING_LITERAL;
657 }
658
VisitImaginaryLiteral(ImaginaryLiteral * E)659 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
660 VisitExpr(E);
661 Record.AddStmt(E->getSubExpr());
662 Code = serialization::EXPR_IMAGINARY_LITERAL;
663 }
664
VisitStringLiteral(StringLiteral * E)665 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
666 VisitExpr(E);
667
668 // Store the various bits of data of StringLiteral.
669 Record.push_back(E->getNumConcatenated());
670 Record.push_back(E->getLength());
671 Record.push_back(E->getCharByteWidth());
672 Record.push_back(E->getKind());
673 Record.push_back(E->isPascal());
674
675 // Store the trailing array of SourceLocation.
676 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
677 Record.AddSourceLocation(E->getStrTokenLoc(I));
678
679 // Store the trailing array of char holding the string data.
680 StringRef StrData = E->getBytes();
681 for (unsigned I = 0, N = E->getByteLength(); I != N; ++I)
682 Record.push_back(StrData[I]);
683
684 Code = serialization::EXPR_STRING_LITERAL;
685 }
686
VisitCharacterLiteral(CharacterLiteral * E)687 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
688 VisitExpr(E);
689 Record.push_back(E->getValue());
690 Record.AddSourceLocation(E->getLocation());
691 Record.push_back(E->getKind());
692
693 AbbrevToUse = Writer.getCharacterLiteralAbbrev();
694
695 Code = serialization::EXPR_CHARACTER_LITERAL;
696 }
697
VisitParenExpr(ParenExpr * E)698 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
699 VisitExpr(E);
700 Record.AddSourceLocation(E->getLParen());
701 Record.AddSourceLocation(E->getRParen());
702 Record.AddStmt(E->getSubExpr());
703 Code = serialization::EXPR_PAREN;
704 }
705
VisitNoChangeBoundsExpr(NoChangeBoundsExpr * E)706 void ASTStmtWriter::VisitNoChangeBoundsExpr(NoChangeBoundsExpr *E) {
707 VisitExpr(E);
708 Record.AddSourceLocation(E->getBuiltinLoc());
709 Record.AddSourceLocation(E->getRParen());
710 Record.AddStmt(E->getSubExpr());
711 Code = serialization::EXPR_NO_CHANGE_BOUNDS;
712 }
713
VisitParenListExpr(ParenListExpr * E)714 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
715 VisitExpr(E);
716 Record.push_back(E->getNumExprs());
717 for (auto *SubStmt : E->exprs())
718 Record.AddStmt(SubStmt);
719 Record.AddSourceLocation(E->getLParenLoc());
720 Record.AddSourceLocation(E->getRParenLoc());
721 Code = serialization::EXPR_PAREN_LIST;
722 }
723
VisitUnaryOperator(UnaryOperator * E)724 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
725 VisitExpr(E);
726 bool HasFPFeatures = E->hasStoredFPFeatures();
727 // Write this first for easy access when deserializing, as they affect the
728 // size of the UnaryOperator.
729 Record.push_back(HasFPFeatures);
730 Record.AddStmt(E->getSubExpr());
731 Record.push_back(E->getOpcode()); // FIXME: stable encoding
732 Record.AddSourceLocation(E->getOperatorLoc());
733 Record.push_back(E->canOverflow());
734 if (HasFPFeatures)
735 Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
736 Code = serialization::EXPR_UNARY_OPERATOR;
737 }
738
VisitOffsetOfExpr(OffsetOfExpr * E)739 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
740 VisitExpr(E);
741 Record.push_back(E->getNumComponents());
742 Record.push_back(E->getNumExpressions());
743 Record.AddSourceLocation(E->getOperatorLoc());
744 Record.AddSourceLocation(E->getRParenLoc());
745 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
746 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
747 const OffsetOfNode &ON = E->getComponent(I);
748 Record.push_back(ON.getKind()); // FIXME: Stable encoding
749 Record.AddSourceLocation(ON.getSourceRange().getBegin());
750 Record.AddSourceLocation(ON.getSourceRange().getEnd());
751 switch (ON.getKind()) {
752 case OffsetOfNode::Array:
753 Record.push_back(ON.getArrayExprIndex());
754 break;
755
756 case OffsetOfNode::Field:
757 Record.AddDeclRef(ON.getField());
758 break;
759
760 case OffsetOfNode::Identifier:
761 Record.AddIdentifierRef(ON.getFieldName());
762 break;
763
764 case OffsetOfNode::Base:
765 Record.AddCXXBaseSpecifier(*ON.getBase());
766 break;
767 }
768 }
769 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
770 Record.AddStmt(E->getIndexExpr(I));
771 Code = serialization::EXPR_OFFSETOF;
772 }
773
VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr * E)774 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
775 VisitExpr(E);
776 Record.push_back(E->getKind());
777 if (E->isArgumentType())
778 Record.AddTypeSourceInfo(E->getArgumentTypeInfo());
779 else {
780 Record.push_back(0);
781 Record.AddStmt(E->getArgumentExpr());
782 }
783 Record.AddSourceLocation(E->getOperatorLoc());
784 Record.AddSourceLocation(E->getRParenLoc());
785 Code = serialization::EXPR_SIZEOF_ALIGN_OF;
786 }
787
VisitArraySubscriptExpr(ArraySubscriptExpr * E)788 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
789 VisitExpr(E);
790 Record.AddStmt(E->getLHS());
791 Record.AddStmt(E->getRHS());
792 Record.AddSourceLocation(E->getRBracketLoc());
793 Code = serialization::EXPR_ARRAY_SUBSCRIPT;
794 }
795
VisitMatrixSubscriptExpr(MatrixSubscriptExpr * E)796 void ASTStmtWriter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
797 VisitExpr(E);
798 Record.AddStmt(E->getBase());
799 Record.AddStmt(E->getRowIdx());
800 Record.AddStmt(E->getColumnIdx());
801 Record.AddSourceLocation(E->getRBracketLoc());
802 Code = serialization::EXPR_ARRAY_SUBSCRIPT;
803 }
804
VisitOMPArraySectionExpr(OMPArraySectionExpr * E)805 void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
806 VisitExpr(E);
807 Record.AddStmt(E->getBase());
808 Record.AddStmt(E->getLowerBound());
809 Record.AddStmt(E->getLength());
810 Record.AddStmt(E->getStride());
811 Record.AddSourceLocation(E->getColonLocFirst());
812 Record.AddSourceLocation(E->getColonLocSecond());
813 Record.AddSourceLocation(E->getRBracketLoc());
814 Code = serialization::EXPR_OMP_ARRAY_SECTION;
815 }
816
VisitOMPArrayShapingExpr(OMPArrayShapingExpr * E)817 void ASTStmtWriter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
818 VisitExpr(E);
819 Record.push_back(E->getDimensions().size());
820 Record.AddStmt(E->getBase());
821 for (Expr *Dim : E->getDimensions())
822 Record.AddStmt(Dim);
823 for (SourceRange SR : E->getBracketsRanges())
824 Record.AddSourceRange(SR);
825 Record.AddSourceLocation(E->getLParenLoc());
826 Record.AddSourceLocation(E->getRParenLoc());
827 Code = serialization::EXPR_OMP_ARRAY_SHAPING;
828 }
829
VisitOMPIteratorExpr(OMPIteratorExpr * E)830 void ASTStmtWriter::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
831 VisitExpr(E);
832 Record.push_back(E->numOfIterators());
833 Record.AddSourceLocation(E->getIteratorKwLoc());
834 Record.AddSourceLocation(E->getLParenLoc());
835 Record.AddSourceLocation(E->getRParenLoc());
836 for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {
837 Record.AddDeclRef(E->getIteratorDecl(I));
838 Record.AddSourceLocation(E->getAssignLoc(I));
839 OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
840 Record.AddStmt(Range.Begin);
841 Record.AddStmt(Range.End);
842 Record.AddStmt(Range.Step);
843 Record.AddSourceLocation(E->getColonLoc(I));
844 if (Range.Step)
845 Record.AddSourceLocation(E->getSecondColonLoc(I));
846 // Serialize helpers
847 OMPIteratorHelperData &HD = E->getHelper(I);
848 Record.AddDeclRef(HD.CounterVD);
849 Record.AddStmt(HD.Upper);
850 Record.AddStmt(HD.Update);
851 Record.AddStmt(HD.CounterUpdate);
852 }
853 Code = serialization::EXPR_OMP_ITERATOR;
854 }
855
VisitCallExpr(CallExpr * E)856 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
857 VisitExpr(E);
858 Record.push_back(E->getNumArgs());
859 Record.AddSourceLocation(E->getRParenLoc());
860 Record.AddStmt(E->getCallee());
861 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
862 Arg != ArgEnd; ++Arg)
863 Record.AddStmt(*Arg);
864 Record.push_back(static_cast<unsigned>(E->getADLCallKind()));
865 Code = serialization::EXPR_CALL;
866 }
867
VisitRecoveryExpr(RecoveryExpr * E)868 void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) {
869 VisitExpr(E);
870 Record.push_back(std::distance(E->children().begin(), E->children().end()));
871 Record.AddSourceLocation(E->getBeginLoc());
872 Record.AddSourceLocation(E->getEndLoc());
873 for (Stmt *Child : E->children())
874 Record.AddStmt(Child);
875 Code = serialization::EXPR_RECOVERY;
876 }
877
VisitMemberExpr(MemberExpr * E)878 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
879 VisitExpr(E);
880
881 bool HasQualifier = E->hasQualifier();
882 bool HasFoundDecl =
883 E->hasQualifierOrFoundDecl() &&
884 (E->getFoundDecl().getDecl() != E->getMemberDecl() ||
885 E->getFoundDecl().getAccess() != E->getMemberDecl()->getAccess());
886 bool HasTemplateInfo = E->hasTemplateKWAndArgsInfo();
887 unsigned NumTemplateArgs = E->getNumTemplateArgs();
888
889 // Write these first for easy access when deserializing, as they affect the
890 // size of the MemberExpr.
891 Record.push_back(HasQualifier);
892 Record.push_back(HasFoundDecl);
893 Record.push_back(HasTemplateInfo);
894 Record.push_back(NumTemplateArgs);
895
896 Record.AddStmt(E->getBase());
897 Record.AddDeclRef(E->getMemberDecl());
898 Record.AddDeclarationNameLoc(E->MemberDNLoc,
899 E->getMemberDecl()->getDeclName());
900 Record.AddSourceLocation(E->getMemberLoc());
901 Record.push_back(E->isArrow());
902 Record.push_back(E->hadMultipleCandidates());
903 Record.push_back(E->isNonOdrUse());
904 Record.AddSourceLocation(E->getOperatorLoc());
905
906 if (HasFoundDecl) {
907 DeclAccessPair FoundDecl = E->getFoundDecl();
908 Record.AddDeclRef(FoundDecl.getDecl());
909 Record.push_back(FoundDecl.getAccess());
910 }
911
912 if (HasQualifier)
913 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
914
915 if (HasTemplateInfo)
916 AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
917 E->getTrailingObjects<TemplateArgumentLoc>());
918
919 Code = serialization::EXPR_MEMBER;
920 }
921
VisitObjCIsaExpr(ObjCIsaExpr * E)922 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
923 VisitExpr(E);
924 Record.AddStmt(E->getBase());
925 Record.AddSourceLocation(E->getIsaMemberLoc());
926 Record.AddSourceLocation(E->getOpLoc());
927 Record.push_back(E->isArrow());
928 Code = serialization::EXPR_OBJC_ISA;
929 }
930
931 void ASTStmtWriter::
VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr * E)932 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
933 VisitExpr(E);
934 Record.AddStmt(E->getSubExpr());
935 Record.push_back(E->shouldCopy());
936 Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE;
937 }
938
VisitObjCBridgedCastExpr(ObjCBridgedCastExpr * E)939 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
940 VisitExplicitCastExpr(E);
941 Record.AddSourceLocation(E->getLParenLoc());
942 Record.AddSourceLocation(E->getBridgeKeywordLoc());
943 Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
944 Code = serialization::EXPR_OBJC_BRIDGED_CAST;
945 }
946
VisitCastExpr(CastExpr * E)947 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
948 VisitExpr(E);
949 Record.push_back(E->path_size());
950 Record.AddStmt(E->getSubExpr());
951 Record.push_back(E->getCastKind()); // FIXME: stable encoding
952
953 for (CastExpr::path_iterator
954 PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
955 Record.AddCXXBaseSpecifier(**PI);
956 }
957
VisitBinaryOperator(BinaryOperator * E)958 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
959 VisitExpr(E);
960 bool HasFPFeatures = E->hasStoredFPFeatures();
961 // Write this first for easy access when deserializing, as they affect the
962 // size of the UnaryOperator.
963 Record.push_back(HasFPFeatures);
964 Record.push_back(E->getOpcode()); // FIXME: stable encoding
965 Record.AddStmt(E->getLHS());
966 Record.AddStmt(E->getRHS());
967 Record.AddSourceLocation(E->getOperatorLoc());
968 if (HasFPFeatures)
969 Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
970 Code = serialization::EXPR_BINARY_OPERATOR;
971 }
972
VisitCompoundAssignOperator(CompoundAssignOperator * E)973 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
974 VisitBinaryOperator(E);
975 Record.AddTypeRef(E->getComputationLHSType());
976 Record.AddTypeRef(E->getComputationResultType());
977 Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
978 }
979
VisitConditionalOperator(ConditionalOperator * E)980 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
981 VisitExpr(E);
982 Record.AddStmt(E->getCond());
983 Record.AddStmt(E->getLHS());
984 Record.AddStmt(E->getRHS());
985 Record.AddSourceLocation(E->getQuestionLoc());
986 Record.AddSourceLocation(E->getColonLoc());
987 Code = serialization::EXPR_CONDITIONAL_OPERATOR;
988 }
989
990 void
VisitBinaryConditionalOperator(BinaryConditionalOperator * E)991 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
992 VisitExpr(E);
993 Record.AddStmt(E->getOpaqueValue());
994 Record.AddStmt(E->getCommon());
995 Record.AddStmt(E->getCond());
996 Record.AddStmt(E->getTrueExpr());
997 Record.AddStmt(E->getFalseExpr());
998 Record.AddSourceLocation(E->getQuestionLoc());
999 Record.AddSourceLocation(E->getColonLoc());
1000 Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
1001 }
1002
VisitImplicitCastExpr(ImplicitCastExpr * E)1003 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1004 VisitCastExpr(E);
1005 Record.push_back(E->isPartOfExplicitCast());
1006
1007 if (E->path_size() == 0)
1008 AbbrevToUse = Writer.getExprImplicitCastAbbrev();
1009
1010 Code = serialization::EXPR_IMPLICIT_CAST;
1011 }
1012
VisitExplicitCastExpr(ExplicitCastExpr * E)1013 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1014 VisitCastExpr(E);
1015 Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());
1016 }
1017
VisitCStyleCastExpr(CStyleCastExpr * E)1018 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
1019 VisitExplicitCastExpr(E);
1020 Record.AddSourceLocation(E->getLParenLoc());
1021 Record.AddSourceLocation(E->getRParenLoc());
1022 Code = serialization::EXPR_CSTYLE_CAST;
1023 }
1024
VisitCompoundLiteralExpr(CompoundLiteralExpr * E)1025 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1026 VisitExpr(E);
1027 Record.AddSourceLocation(E->getLParenLoc());
1028 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1029 Record.AddStmt(E->getInitializer());
1030 Record.push_back(E->isFileScope());
1031 Code = serialization::EXPR_COMPOUND_LITERAL;
1032 }
1033
VisitExtVectorElementExpr(ExtVectorElementExpr * E)1034 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1035 VisitExpr(E);
1036 Record.AddStmt(E->getBase());
1037 Record.AddIdentifierRef(&E->getAccessor());
1038 Record.AddSourceLocation(E->getAccessorLoc());
1039 Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
1040 }
1041
VisitInitListExpr(InitListExpr * E)1042 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
1043 VisitExpr(E);
1044 // NOTE: only add the (possibly null) syntactic form.
1045 // No need to serialize the isSemanticForm flag and the semantic form.
1046 Record.AddStmt(E->getSyntacticForm());
1047 Record.AddSourceLocation(E->getLBraceLoc());
1048 Record.AddSourceLocation(E->getRBraceLoc());
1049 bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
1050 Record.push_back(isArrayFiller);
1051 if (isArrayFiller)
1052 Record.AddStmt(E->getArrayFiller());
1053 else
1054 Record.AddDeclRef(E->getInitializedFieldInUnion());
1055 Record.push_back(E->hadArrayRangeDesignator());
1056 Record.push_back(E->getNumInits());
1057 if (isArrayFiller) {
1058 // ArrayFiller may have filled "holes" due to designated initializer.
1059 // Replace them by 0 to indicate that the filler goes in that place.
1060 Expr *filler = E->getArrayFiller();
1061 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
1062 Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);
1063 } else {
1064 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
1065 Record.AddStmt(E->getInit(I));
1066 }
1067 Code = serialization::EXPR_INIT_LIST;
1068 }
1069
VisitDesignatedInitExpr(DesignatedInitExpr * E)1070 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1071 VisitExpr(E);
1072 Record.push_back(E->getNumSubExprs());
1073 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1074 Record.AddStmt(E->getSubExpr(I));
1075 Record.AddSourceLocation(E->getEqualOrColonLoc());
1076 Record.push_back(E->usesGNUSyntax());
1077 for (const DesignatedInitExpr::Designator &D : E->designators()) {
1078 if (D.isFieldDesignator()) {
1079 if (FieldDecl *Field = D.getField()) {
1080 Record.push_back(serialization::DESIG_FIELD_DECL);
1081 Record.AddDeclRef(Field);
1082 } else {
1083 Record.push_back(serialization::DESIG_FIELD_NAME);
1084 Record.AddIdentifierRef(D.getFieldName());
1085 }
1086 Record.AddSourceLocation(D.getDotLoc());
1087 Record.AddSourceLocation(D.getFieldLoc());
1088 } else if (D.isArrayDesignator()) {
1089 Record.push_back(serialization::DESIG_ARRAY);
1090 Record.push_back(D.getFirstExprIndex());
1091 Record.AddSourceLocation(D.getLBracketLoc());
1092 Record.AddSourceLocation(D.getRBracketLoc());
1093 } else {
1094 assert(D.isArrayRangeDesignator() && "Unknown designator");
1095 Record.push_back(serialization::DESIG_ARRAY_RANGE);
1096 Record.push_back(D.getFirstExprIndex());
1097 Record.AddSourceLocation(D.getLBracketLoc());
1098 Record.AddSourceLocation(D.getEllipsisLoc());
1099 Record.AddSourceLocation(D.getRBracketLoc());
1100 }
1101 }
1102 Code = serialization::EXPR_DESIGNATED_INIT;
1103 }
1104
VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr * E)1105 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1106 VisitExpr(E);
1107 Record.AddStmt(E->getBase());
1108 Record.AddStmt(E->getUpdater());
1109 Code = serialization::EXPR_DESIGNATED_INIT_UPDATE;
1110 }
1111
VisitNoInitExpr(NoInitExpr * E)1112 void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
1113 VisitExpr(E);
1114 Code = serialization::EXPR_NO_INIT;
1115 }
1116
VisitArrayInitLoopExpr(ArrayInitLoopExpr * E)1117 void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1118 VisitExpr(E);
1119 Record.AddStmt(E->SubExprs[0]);
1120 Record.AddStmt(E->SubExprs[1]);
1121 Code = serialization::EXPR_ARRAY_INIT_LOOP;
1122 }
1123
VisitArrayInitIndexExpr(ArrayInitIndexExpr * E)1124 void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1125 VisitExpr(E);
1126 Code = serialization::EXPR_ARRAY_INIT_INDEX;
1127 }
1128
VisitImplicitValueInitExpr(ImplicitValueInitExpr * E)1129 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1130 VisitExpr(E);
1131 Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
1132 }
1133
VisitVAArgExpr(VAArgExpr * E)1134 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
1135 VisitExpr(E);
1136 Record.AddStmt(E->getSubExpr());
1137 Record.AddTypeSourceInfo(E->getWrittenTypeInfo());
1138 Record.AddSourceLocation(E->getBuiltinLoc());
1139 Record.AddSourceLocation(E->getRParenLoc());
1140 Record.push_back(E->isMicrosoftABI());
1141 Code = serialization::EXPR_VA_ARG;
1142 }
1143
VisitSourceLocExpr(SourceLocExpr * E)1144 void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {
1145 VisitExpr(E);
1146 Record.AddDeclRef(cast_or_null<Decl>(E->getParentContext()));
1147 Record.AddSourceLocation(E->getBeginLoc());
1148 Record.AddSourceLocation(E->getEndLoc());
1149 Record.push_back(E->getIdentKind());
1150 Code = serialization::EXPR_SOURCE_LOC;
1151 }
1152
VisitAddrLabelExpr(AddrLabelExpr * E)1153 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
1154 VisitExpr(E);
1155 Record.AddSourceLocation(E->getAmpAmpLoc());
1156 Record.AddSourceLocation(E->getLabelLoc());
1157 Record.AddDeclRef(E->getLabel());
1158 Code = serialization::EXPR_ADDR_LABEL;
1159 }
1160
VisitStmtExpr(StmtExpr * E)1161 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
1162 VisitExpr(E);
1163 Record.AddStmt(E->getSubStmt());
1164 Record.AddSourceLocation(E->getLParenLoc());
1165 Record.AddSourceLocation(E->getRParenLoc());
1166 Record.push_back(E->getTemplateDepth());
1167 Code = serialization::EXPR_STMT;
1168 }
1169
VisitChooseExpr(ChooseExpr * E)1170 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
1171 VisitExpr(E);
1172 Record.AddStmt(E->getCond());
1173 Record.AddStmt(E->getLHS());
1174 Record.AddStmt(E->getRHS());
1175 Record.AddSourceLocation(E->getBuiltinLoc());
1176 Record.AddSourceLocation(E->getRParenLoc());
1177 Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
1178 Code = serialization::EXPR_CHOOSE;
1179 }
1180
VisitGNUNullExpr(GNUNullExpr * E)1181 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
1182 VisitExpr(E);
1183 Record.AddSourceLocation(E->getTokenLocation());
1184 Code = serialization::EXPR_GNU_NULL;
1185 }
1186
VisitShuffleVectorExpr(ShuffleVectorExpr * E)1187 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1188 VisitExpr(E);
1189 Record.push_back(E->getNumSubExprs());
1190 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1191 Record.AddStmt(E->getExpr(I));
1192 Record.AddSourceLocation(E->getBuiltinLoc());
1193 Record.AddSourceLocation(E->getRParenLoc());
1194 Code = serialization::EXPR_SHUFFLE_VECTOR;
1195 }
1196
VisitConvertVectorExpr(ConvertVectorExpr * E)1197 void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1198 VisitExpr(E);
1199 Record.AddSourceLocation(E->getBuiltinLoc());
1200 Record.AddSourceLocation(E->getRParenLoc());
1201 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1202 Record.AddStmt(E->getSrcExpr());
1203 Code = serialization::EXPR_CONVERT_VECTOR;
1204 }
1205
VisitBlockExpr(BlockExpr * E)1206 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
1207 VisitExpr(E);
1208 Record.AddDeclRef(E->getBlockDecl());
1209 Code = serialization::EXPR_BLOCK;
1210 }
1211
VisitGenericSelectionExpr(GenericSelectionExpr * E)1212 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1213 VisitExpr(E);
1214
1215 Record.push_back(E->getNumAssocs());
1216 Record.push_back(E->ResultIndex);
1217 Record.AddSourceLocation(E->getGenericLoc());
1218 Record.AddSourceLocation(E->getDefaultLoc());
1219 Record.AddSourceLocation(E->getRParenLoc());
1220
1221 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1222 // Add 1 to account for the controlling expression which is the first
1223 // expression in the trailing array of Stmt *. This is not needed for
1224 // the trailing array of TypeSourceInfo *.
1225 for (unsigned I = 0, N = E->getNumAssocs() + 1; I < N; ++I)
1226 Record.AddStmt(Stmts[I]);
1227
1228 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1229 for (unsigned I = 0, N = E->getNumAssocs(); I < N; ++I)
1230 Record.AddTypeSourceInfo(TSIs[I]);
1231
1232 Code = serialization::EXPR_GENERIC_SELECTION;
1233 }
1234
VisitPseudoObjectExpr(PseudoObjectExpr * E)1235 void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1236 VisitExpr(E);
1237 Record.push_back(E->getNumSemanticExprs());
1238
1239 // Push the result index. Currently, this needs to exactly match
1240 // the encoding used internally for ResultIndex.
1241 unsigned result = E->getResultExprIndex();
1242 result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1);
1243 Record.push_back(result);
1244
1245 Record.AddStmt(E->getSyntacticForm());
1246 for (PseudoObjectExpr::semantics_iterator
1247 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
1248 Record.AddStmt(*i);
1249 }
1250 Code = serialization::EXPR_PSEUDO_OBJECT;
1251 }
1252
VisitAtomicExpr(AtomicExpr * E)1253 void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
1254 VisitExpr(E);
1255 Record.push_back(E->getOp());
1256 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1257 Record.AddStmt(E->getSubExprs()[I]);
1258 Record.AddSourceLocation(E->getBuiltinLoc());
1259 Record.AddSourceLocation(E->getRParenLoc());
1260 Code = serialization::EXPR_ATOMIC;
1261 }
1262
1263 //===----------------------------------------------------------------------===//
1264 // Objective-C Expressions and Statements.
1265 //===----------------------------------------------------------------------===//
1266
VisitObjCStringLiteral(ObjCStringLiteral * E)1267 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1268 VisitExpr(E);
1269 Record.AddStmt(E->getString());
1270 Record.AddSourceLocation(E->getAtLoc());
1271 Code = serialization::EXPR_OBJC_STRING_LITERAL;
1272 }
1273
VisitObjCBoxedExpr(ObjCBoxedExpr * E)1274 void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1275 VisitExpr(E);
1276 Record.AddStmt(E->getSubExpr());
1277 Record.AddDeclRef(E->getBoxingMethod());
1278 Record.AddSourceRange(E->getSourceRange());
1279 Code = serialization::EXPR_OBJC_BOXED_EXPRESSION;
1280 }
1281
VisitObjCArrayLiteral(ObjCArrayLiteral * E)1282 void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1283 VisitExpr(E);
1284 Record.push_back(E->getNumElements());
1285 for (unsigned i = 0; i < E->getNumElements(); i++)
1286 Record.AddStmt(E->getElement(i));
1287 Record.AddDeclRef(E->getArrayWithObjectsMethod());
1288 Record.AddSourceRange(E->getSourceRange());
1289 Code = serialization::EXPR_OBJC_ARRAY_LITERAL;
1290 }
1291
VisitObjCDictionaryLiteral(ObjCDictionaryLiteral * E)1292 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1293 VisitExpr(E);
1294 Record.push_back(E->getNumElements());
1295 Record.push_back(E->HasPackExpansions);
1296 for (unsigned i = 0; i < E->getNumElements(); i++) {
1297 ObjCDictionaryElement Element = E->getKeyValueElement(i);
1298 Record.AddStmt(Element.Key);
1299 Record.AddStmt(Element.Value);
1300 if (E->HasPackExpansions) {
1301 Record.AddSourceLocation(Element.EllipsisLoc);
1302 unsigned NumExpansions = 0;
1303 if (Element.NumExpansions)
1304 NumExpansions = *Element.NumExpansions + 1;
1305 Record.push_back(NumExpansions);
1306 }
1307 }
1308
1309 Record.AddDeclRef(E->getDictWithObjectsMethod());
1310 Record.AddSourceRange(E->getSourceRange());
1311 Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL;
1312 }
1313
VisitObjCEncodeExpr(ObjCEncodeExpr * E)1314 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1315 VisitExpr(E);
1316 Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo());
1317 Record.AddSourceLocation(E->getAtLoc());
1318 Record.AddSourceLocation(E->getRParenLoc());
1319 Code = serialization::EXPR_OBJC_ENCODE;
1320 }
1321
VisitObjCSelectorExpr(ObjCSelectorExpr * E)1322 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1323 VisitExpr(E);
1324 Record.AddSelectorRef(E->getSelector());
1325 Record.AddSourceLocation(E->getAtLoc());
1326 Record.AddSourceLocation(E->getRParenLoc());
1327 Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
1328 }
1329
VisitObjCProtocolExpr(ObjCProtocolExpr * E)1330 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1331 VisitExpr(E);
1332 Record.AddDeclRef(E->getProtocol());
1333 Record.AddSourceLocation(E->getAtLoc());
1334 Record.AddSourceLocation(E->ProtoLoc);
1335 Record.AddSourceLocation(E->getRParenLoc());
1336 Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
1337 }
1338
VisitObjCIvarRefExpr(ObjCIvarRefExpr * E)1339 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1340 VisitExpr(E);
1341 Record.AddDeclRef(E->getDecl());
1342 Record.AddSourceLocation(E->getLocation());
1343 Record.AddSourceLocation(E->getOpLoc());
1344 Record.AddStmt(E->getBase());
1345 Record.push_back(E->isArrow());
1346 Record.push_back(E->isFreeIvar());
1347 Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
1348 }
1349
VisitObjCPropertyRefExpr(ObjCPropertyRefExpr * E)1350 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1351 VisitExpr(E);
1352 Record.push_back(E->SetterAndMethodRefFlags.getInt());
1353 Record.push_back(E->isImplicitProperty());
1354 if (E->isImplicitProperty()) {
1355 Record.AddDeclRef(E->getImplicitPropertyGetter());
1356 Record.AddDeclRef(E->getImplicitPropertySetter());
1357 } else {
1358 Record.AddDeclRef(E->getExplicitProperty());
1359 }
1360 Record.AddSourceLocation(E->getLocation());
1361 Record.AddSourceLocation(E->getReceiverLocation());
1362 if (E->isObjectReceiver()) {
1363 Record.push_back(0);
1364 Record.AddStmt(E->getBase());
1365 } else if (E->isSuperReceiver()) {
1366 Record.push_back(1);
1367 Record.AddTypeRef(E->getSuperReceiverType());
1368 } else {
1369 Record.push_back(2);
1370 Record.AddDeclRef(E->getClassReceiver());
1371 }
1372
1373 Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
1374 }
1375
VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr * E)1376 void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1377 VisitExpr(E);
1378 Record.AddSourceLocation(E->getRBracket());
1379 Record.AddStmt(E->getBaseExpr());
1380 Record.AddStmt(E->getKeyExpr());
1381 Record.AddDeclRef(E->getAtIndexMethodDecl());
1382 Record.AddDeclRef(E->setAtIndexMethodDecl());
1383
1384 Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR;
1385 }
1386
VisitObjCMessageExpr(ObjCMessageExpr * E)1387 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1388 VisitExpr(E);
1389 Record.push_back(E->getNumArgs());
1390 Record.push_back(E->getNumStoredSelLocs());
1391 Record.push_back(E->SelLocsKind);
1392 Record.push_back(E->isDelegateInitCall());
1393 Record.push_back(E->IsImplicit);
1394 Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
1395 switch (E->getReceiverKind()) {
1396 case ObjCMessageExpr::Instance:
1397 Record.AddStmt(E->getInstanceReceiver());
1398 break;
1399
1400 case ObjCMessageExpr::Class:
1401 Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo());
1402 break;
1403
1404 case ObjCMessageExpr::SuperClass:
1405 case ObjCMessageExpr::SuperInstance:
1406 Record.AddTypeRef(E->getSuperType());
1407 Record.AddSourceLocation(E->getSuperLoc());
1408 break;
1409 }
1410
1411 if (E->getMethodDecl()) {
1412 Record.push_back(1);
1413 Record.AddDeclRef(E->getMethodDecl());
1414 } else {
1415 Record.push_back(0);
1416 Record.AddSelectorRef(E->getSelector());
1417 }
1418
1419 Record.AddSourceLocation(E->getLeftLoc());
1420 Record.AddSourceLocation(E->getRightLoc());
1421
1422 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
1423 Arg != ArgEnd; ++Arg)
1424 Record.AddStmt(*Arg);
1425
1426 SourceLocation *Locs = E->getStoredSelLocs();
1427 for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
1428 Record.AddSourceLocation(Locs[i]);
1429
1430 Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
1431 }
1432
VisitObjCForCollectionStmt(ObjCForCollectionStmt * S)1433 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1434 VisitStmt(S);
1435 Record.AddStmt(S->getElement());
1436 Record.AddStmt(S->getCollection());
1437 Record.AddStmt(S->getBody());
1438 Record.AddSourceLocation(S->getForLoc());
1439 Record.AddSourceLocation(S->getRParenLoc());
1440 Code = serialization::STMT_OBJC_FOR_COLLECTION;
1441 }
1442
VisitObjCAtCatchStmt(ObjCAtCatchStmt * S)1443 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1444 VisitStmt(S);
1445 Record.AddStmt(S->getCatchBody());
1446 Record.AddDeclRef(S->getCatchParamDecl());
1447 Record.AddSourceLocation(S->getAtCatchLoc());
1448 Record.AddSourceLocation(S->getRParenLoc());
1449 Code = serialization::STMT_OBJC_CATCH;
1450 }
1451
VisitObjCAtFinallyStmt(ObjCAtFinallyStmt * S)1452 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1453 VisitStmt(S);
1454 Record.AddStmt(S->getFinallyBody());
1455 Record.AddSourceLocation(S->getAtFinallyLoc());
1456 Code = serialization::STMT_OBJC_FINALLY;
1457 }
1458
VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt * S)1459 void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1460 VisitStmt(S); // FIXME: no test coverage.
1461 Record.AddStmt(S->getSubStmt());
1462 Record.AddSourceLocation(S->getAtLoc());
1463 Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
1464 }
1465
VisitObjCAtTryStmt(ObjCAtTryStmt * S)1466 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1467 VisitStmt(S);
1468 Record.push_back(S->getNumCatchStmts());
1469 Record.push_back(S->getFinallyStmt() != nullptr);
1470 Record.AddStmt(S->getTryBody());
1471 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1472 Record.AddStmt(S->getCatchStmt(I));
1473 if (S->getFinallyStmt())
1474 Record.AddStmt(S->getFinallyStmt());
1475 Record.AddSourceLocation(S->getAtTryLoc());
1476 Code = serialization::STMT_OBJC_AT_TRY;
1477 }
1478
VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt * S)1479 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1480 VisitStmt(S); // FIXME: no test coverage.
1481 Record.AddStmt(S->getSynchExpr());
1482 Record.AddStmt(S->getSynchBody());
1483 Record.AddSourceLocation(S->getAtSynchronizedLoc());
1484 Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
1485 }
1486
VisitObjCAtThrowStmt(ObjCAtThrowStmt * S)1487 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1488 VisitStmt(S); // FIXME: no test coverage.
1489 Record.AddStmt(S->getThrowExpr());
1490 Record.AddSourceLocation(S->getThrowLoc());
1491 Code = serialization::STMT_OBJC_AT_THROW;
1492 }
1493
VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr * E)1494 void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1495 VisitExpr(E);
1496 Record.push_back(E->getValue());
1497 Record.AddSourceLocation(E->getLocation());
1498 Code = serialization::EXPR_OBJC_BOOL_LITERAL;
1499 }
1500
VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr * E)1501 void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1502 VisitExpr(E);
1503 Record.AddSourceRange(E->getSourceRange());
1504 Record.AddVersionTuple(E->getVersion());
1505 Code = serialization::EXPR_OBJC_AVAILABILITY_CHECK;
1506 }
1507
1508 //===----------------------------------------------------------------------===//
1509 // C++ Expressions and Statements.
1510 //===----------------------------------------------------------------------===//
1511
VisitCXXCatchStmt(CXXCatchStmt * S)1512 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
1513 VisitStmt(S);
1514 Record.AddSourceLocation(S->getCatchLoc());
1515 Record.AddDeclRef(S->getExceptionDecl());
1516 Record.AddStmt(S->getHandlerBlock());
1517 Code = serialization::STMT_CXX_CATCH;
1518 }
1519
VisitCXXTryStmt(CXXTryStmt * S)1520 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
1521 VisitStmt(S);
1522 Record.push_back(S->getNumHandlers());
1523 Record.AddSourceLocation(S->getTryLoc());
1524 Record.AddStmt(S->getTryBlock());
1525 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1526 Record.AddStmt(S->getHandler(i));
1527 Code = serialization::STMT_CXX_TRY;
1528 }
1529
VisitCXXForRangeStmt(CXXForRangeStmt * S)1530 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1531 VisitStmt(S);
1532 Record.AddSourceLocation(S->getForLoc());
1533 Record.AddSourceLocation(S->getCoawaitLoc());
1534 Record.AddSourceLocation(S->getColonLoc());
1535 Record.AddSourceLocation(S->getRParenLoc());
1536 Record.AddStmt(S->getInit());
1537 Record.AddStmt(S->getRangeStmt());
1538 Record.AddStmt(S->getBeginStmt());
1539 Record.AddStmt(S->getEndStmt());
1540 Record.AddStmt(S->getCond());
1541 Record.AddStmt(S->getInc());
1542 Record.AddStmt(S->getLoopVarStmt());
1543 Record.AddStmt(S->getBody());
1544 Code = serialization::STMT_CXX_FOR_RANGE;
1545 }
1546
VisitMSDependentExistsStmt(MSDependentExistsStmt * S)1547 void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1548 VisitStmt(S);
1549 Record.AddSourceLocation(S->getKeywordLoc());
1550 Record.push_back(S->isIfExists());
1551 Record.AddNestedNameSpecifierLoc(S->getQualifierLoc());
1552 Record.AddDeclarationNameInfo(S->getNameInfo());
1553 Record.AddStmt(S->getSubStmt());
1554 Code = serialization::STMT_MS_DEPENDENT_EXISTS;
1555 }
1556
VisitCXXOperatorCallExpr(CXXOperatorCallExpr * E)1557 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1558 VisitCallExpr(E);
1559 Record.push_back(E->getOperator());
1560 Record.AddSourceRange(E->Range);
1561 Record.push_back(E->getFPFeatures().getAsOpaqueInt());
1562 Code = serialization::EXPR_CXX_OPERATOR_CALL;
1563 }
1564
VisitCXXMemberCallExpr(CXXMemberCallExpr * E)1565 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1566 VisitCallExpr(E);
1567 Code = serialization::EXPR_CXX_MEMBER_CALL;
1568 }
1569
VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator * E)1570 void ASTStmtWriter::VisitCXXRewrittenBinaryOperator(
1571 CXXRewrittenBinaryOperator *E) {
1572 VisitExpr(E);
1573 Record.push_back(E->isReversed());
1574 Record.AddStmt(E->getSemanticForm());
1575 Code = serialization::EXPR_CXX_REWRITTEN_BINARY_OPERATOR;
1576 }
1577
VisitCXXConstructExpr(CXXConstructExpr * E)1578 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1579 VisitExpr(E);
1580
1581 Record.push_back(E->getNumArgs());
1582 Record.push_back(E->isElidable());
1583 Record.push_back(E->hadMultipleCandidates());
1584 Record.push_back(E->isListInitialization());
1585 Record.push_back(E->isStdInitListInitialization());
1586 Record.push_back(E->requiresZeroInitialization());
1587 Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1588 Record.AddSourceLocation(E->getLocation());
1589 Record.AddDeclRef(E->getConstructor());
1590 Record.AddSourceRange(E->getParenOrBraceRange());
1591
1592 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1593 Record.AddStmt(E->getArg(I));
1594
1595 Code = serialization::EXPR_CXX_CONSTRUCT;
1596 }
1597
VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr * E)1598 void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1599 VisitExpr(E);
1600 Record.AddDeclRef(E->getConstructor());
1601 Record.AddSourceLocation(E->getLocation());
1602 Record.push_back(E->constructsVBase());
1603 Record.push_back(E->inheritedFromVBase());
1604 Code = serialization::EXPR_CXX_INHERITED_CTOR_INIT;
1605 }
1606
VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr * E)1607 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1608 VisitCXXConstructExpr(E);
1609 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1610 Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1611 }
1612
VisitLambdaExpr(LambdaExpr * E)1613 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1614 VisitExpr(E);
1615 Record.push_back(E->LambdaExprBits.NumCaptures);
1616 Record.AddSourceRange(E->IntroducerRange);
1617 Record.push_back(E->LambdaExprBits.CaptureDefault); // FIXME: stable encoding
1618 Record.AddSourceLocation(E->CaptureDefaultLoc);
1619 Record.push_back(E->LambdaExprBits.ExplicitParams);
1620 Record.push_back(E->LambdaExprBits.ExplicitResultType);
1621 Record.AddSourceLocation(E->ClosingBrace);
1622
1623 // Add capture initializers.
1624 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1625 CEnd = E->capture_init_end();
1626 C != CEnd; ++C) {
1627 Record.AddStmt(*C);
1628 }
1629
1630 // Don't serialize the body. It belongs to the call operator declaration.
1631 // LambdaExpr only stores a copy of the Stmt *.
1632
1633 Code = serialization::EXPR_LAMBDA;
1634 }
1635
VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr * E)1636 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1637 VisitExpr(E);
1638 Record.AddStmt(E->getSubExpr());
1639 Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST;
1640 }
1641
VisitCXXNamedCastExpr(CXXNamedCastExpr * E)1642 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1643 VisitExplicitCastExpr(E);
1644 Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()));
1645 Record.AddSourceRange(E->getAngleBrackets());
1646 }
1647
VisitCXXStaticCastExpr(CXXStaticCastExpr * E)1648 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1649 VisitCXXNamedCastExpr(E);
1650 Code = serialization::EXPR_CXX_STATIC_CAST;
1651 }
1652
VisitCXXDynamicCastExpr(CXXDynamicCastExpr * E)1653 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1654 VisitCXXNamedCastExpr(E);
1655 Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1656 }
1657
VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr * E)1658 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1659 VisitCXXNamedCastExpr(E);
1660 Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1661 }
1662
VisitCXXConstCastExpr(CXXConstCastExpr * E)1663 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1664 VisitCXXNamedCastExpr(E);
1665 Code = serialization::EXPR_CXX_CONST_CAST;
1666 }
1667
VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr * E)1668 void ASTStmtWriter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1669 VisitCXXNamedCastExpr(E);
1670 Code = serialization::EXPR_CXX_ADDRSPACE_CAST;
1671 }
1672
VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr * E)1673 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1674 VisitExplicitCastExpr(E);
1675 Record.AddSourceLocation(E->getLParenLoc());
1676 Record.AddSourceLocation(E->getRParenLoc());
1677 Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1678 }
1679
VisitBuiltinBitCastExpr(BuiltinBitCastExpr * E)1680 void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1681 VisitExplicitCastExpr(E);
1682 Record.AddSourceLocation(E->getBeginLoc());
1683 Record.AddSourceLocation(E->getEndLoc());
1684 Code = serialization::EXPR_BUILTIN_BIT_CAST;
1685 }
1686
VisitUserDefinedLiteral(UserDefinedLiteral * E)1687 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1688 VisitCallExpr(E);
1689 Record.AddSourceLocation(E->UDSuffixLoc);
1690 Code = serialization::EXPR_USER_DEFINED_LITERAL;
1691 }
1692
VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr * E)1693 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1694 VisitExpr(E);
1695 Record.push_back(E->getValue());
1696 Record.AddSourceLocation(E->getLocation());
1697 Code = serialization::EXPR_CXX_BOOL_LITERAL;
1698 }
1699
VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr * E)1700 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1701 VisitExpr(E);
1702 Record.AddSourceLocation(E->getLocation());
1703 Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1704 }
1705
VisitCXXTypeidExpr(CXXTypeidExpr * E)1706 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1707 VisitExpr(E);
1708 Record.AddSourceRange(E->getSourceRange());
1709 if (E->isTypeOperand()) {
1710 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
1711 Code = serialization::EXPR_CXX_TYPEID_TYPE;
1712 } else {
1713 Record.AddStmt(E->getExprOperand());
1714 Code = serialization::EXPR_CXX_TYPEID_EXPR;
1715 }
1716 }
1717
VisitCXXThisExpr(CXXThisExpr * E)1718 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1719 VisitExpr(E);
1720 Record.AddSourceLocation(E->getLocation());
1721 Record.push_back(E->isImplicit());
1722 Code = serialization::EXPR_CXX_THIS;
1723 }
1724
VisitCXXThrowExpr(CXXThrowExpr * E)1725 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1726 VisitExpr(E);
1727 Record.AddSourceLocation(E->getThrowLoc());
1728 Record.AddStmt(E->getSubExpr());
1729 Record.push_back(E->isThrownVariableInScope());
1730 Code = serialization::EXPR_CXX_THROW;
1731 }
1732
VisitCXXDefaultArgExpr(CXXDefaultArgExpr * E)1733 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1734 VisitExpr(E);
1735 Record.AddDeclRef(E->getParam());
1736 Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
1737 Record.AddSourceLocation(E->getUsedLocation());
1738 Code = serialization::EXPR_CXX_DEFAULT_ARG;
1739 }
1740
VisitCXXDefaultInitExpr(CXXDefaultInitExpr * E)1741 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1742 VisitExpr(E);
1743 Record.AddDeclRef(E->getField());
1744 Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
1745 Record.AddSourceLocation(E->getExprLoc());
1746 Code = serialization::EXPR_CXX_DEFAULT_INIT;
1747 }
1748
VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr * E)1749 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1750 VisitExpr(E);
1751 Record.AddCXXTemporary(E->getTemporary());
1752 Record.AddStmt(E->getSubExpr());
1753 Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1754 }
1755
VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr * E)1756 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1757 VisitExpr(E);
1758 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1759 Record.AddSourceLocation(E->getRParenLoc());
1760 Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1761 }
1762
VisitCXXNewExpr(CXXNewExpr * E)1763 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1764 VisitExpr(E);
1765
1766 Record.push_back(E->isArray());
1767 Record.push_back(E->hasInitializer());
1768 Record.push_back(E->getNumPlacementArgs());
1769 Record.push_back(E->isParenTypeId());
1770
1771 Record.push_back(E->isGlobalNew());
1772 Record.push_back(E->passAlignment());
1773 Record.push_back(E->doesUsualArrayDeleteWantSize());
1774 Record.push_back(E->CXXNewExprBits.StoredInitializationStyle);
1775
1776 Record.AddDeclRef(E->getOperatorNew());
1777 Record.AddDeclRef(E->getOperatorDelete());
1778 Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo());
1779 if (E->isParenTypeId())
1780 Record.AddSourceRange(E->getTypeIdParens());
1781 Record.AddSourceRange(E->getSourceRange());
1782 Record.AddSourceRange(E->getDirectInitRange());
1783
1784 for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), N = E->raw_arg_end();
1785 I != N; ++I)
1786 Record.AddStmt(*I);
1787
1788 Code = serialization::EXPR_CXX_NEW;
1789 }
1790
VisitCXXDeleteExpr(CXXDeleteExpr * E)1791 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1792 VisitExpr(E);
1793 Record.push_back(E->isGlobalDelete());
1794 Record.push_back(E->isArrayForm());
1795 Record.push_back(E->isArrayFormAsWritten());
1796 Record.push_back(E->doesUsualArrayDeleteWantSize());
1797 Record.AddDeclRef(E->getOperatorDelete());
1798 Record.AddStmt(E->getArgument());
1799 Record.AddSourceLocation(E->getBeginLoc());
1800
1801 Code = serialization::EXPR_CXX_DELETE;
1802 }
1803
VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr * E)1804 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1805 VisitExpr(E);
1806
1807 Record.AddStmt(E->getBase());
1808 Record.push_back(E->isArrow());
1809 Record.AddSourceLocation(E->getOperatorLoc());
1810 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1811 Record.AddTypeSourceInfo(E->getScopeTypeInfo());
1812 Record.AddSourceLocation(E->getColonColonLoc());
1813 Record.AddSourceLocation(E->getTildeLoc());
1814
1815 // PseudoDestructorTypeStorage.
1816 Record.AddIdentifierRef(E->getDestroyedTypeIdentifier());
1817 if (E->getDestroyedTypeIdentifier())
1818 Record.AddSourceLocation(E->getDestroyedTypeLoc());
1819 else
1820 Record.AddTypeSourceInfo(E->getDestroyedTypeInfo());
1821
1822 Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1823 }
1824
VisitExprWithCleanups(ExprWithCleanups * E)1825 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1826 VisitExpr(E);
1827 Record.push_back(E->getNumObjects());
1828 for (auto &Obj : E->getObjects()) {
1829 if (auto *BD = Obj.dyn_cast<BlockDecl *>()) {
1830 Record.push_back(serialization::COK_Block);
1831 Record.AddDeclRef(BD);
1832 } else if (auto *CLE = Obj.dyn_cast<CompoundLiteralExpr *>()) {
1833 Record.push_back(serialization::COK_CompoundLiteral);
1834 Record.AddStmt(CLE);
1835 }
1836 }
1837
1838 Record.push_back(E->cleanupsHaveSideEffects());
1839 Record.AddStmt(E->getSubExpr());
1840 Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1841 }
1842
VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr * E)1843 void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(
1844 CXXDependentScopeMemberExpr *E) {
1845 VisitExpr(E);
1846
1847 // Don't emit anything here (or if you do you will have to update
1848 // the corresponding deserialization function).
1849
1850 Record.push_back(E->hasTemplateKWAndArgsInfo());
1851 Record.push_back(E->getNumTemplateArgs());
1852 Record.push_back(E->hasFirstQualifierFoundInScope());
1853
1854 if (E->hasTemplateKWAndArgsInfo()) {
1855 const ASTTemplateKWAndArgsInfo &ArgInfo =
1856 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1857 AddTemplateKWAndArgsInfo(ArgInfo,
1858 E->getTrailingObjects<TemplateArgumentLoc>());
1859 }
1860
1861 Record.push_back(E->isArrow());
1862 Record.AddSourceLocation(E->getOperatorLoc());
1863 Record.AddTypeRef(E->getBaseType());
1864 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1865 if (!E->isImplicitAccess())
1866 Record.AddStmt(E->getBase());
1867 else
1868 Record.AddStmt(nullptr);
1869
1870 if (E->hasFirstQualifierFoundInScope())
1871 Record.AddDeclRef(E->getFirstQualifierFoundInScope());
1872
1873 Record.AddDeclarationNameInfo(E->MemberNameInfo);
1874 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1875 }
1876
1877 void
VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr * E)1878 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1879 VisitExpr(E);
1880
1881 // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1882 // emitted first.
1883
1884 Record.push_back(E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo);
1885 if (E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo) {
1886 const ASTTemplateKWAndArgsInfo &ArgInfo =
1887 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1888 Record.push_back(ArgInfo.NumTemplateArgs);
1889 AddTemplateKWAndArgsInfo(ArgInfo,
1890 E->getTrailingObjects<TemplateArgumentLoc>());
1891 }
1892
1893 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1894 Record.AddDeclarationNameInfo(E->NameInfo);
1895 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1896 }
1897
1898 void
VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr * E)1899 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1900 VisitExpr(E);
1901 Record.push_back(E->arg_size());
1902 for (CXXUnresolvedConstructExpr::arg_iterator
1903 ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1904 Record.AddStmt(*ArgI);
1905 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1906 Record.AddSourceLocation(E->getLParenLoc());
1907 Record.AddSourceLocation(E->getRParenLoc());
1908 Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1909 }
1910
VisitOverloadExpr(OverloadExpr * E)1911 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1912 VisitExpr(E);
1913
1914 Record.push_back(E->getNumDecls());
1915 Record.push_back(E->hasTemplateKWAndArgsInfo());
1916 if (E->hasTemplateKWAndArgsInfo()) {
1917 const ASTTemplateKWAndArgsInfo &ArgInfo =
1918 *E->getTrailingASTTemplateKWAndArgsInfo();
1919 Record.push_back(ArgInfo.NumTemplateArgs);
1920 AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
1921 }
1922
1923 for (OverloadExpr::decls_iterator OvI = E->decls_begin(),
1924 OvE = E->decls_end();
1925 OvI != OvE; ++OvI) {
1926 Record.AddDeclRef(OvI.getDecl());
1927 Record.push_back(OvI.getAccess());
1928 }
1929
1930 Record.AddDeclarationNameInfo(E->getNameInfo());
1931 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1932 }
1933
VisitUnresolvedMemberExpr(UnresolvedMemberExpr * E)1934 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1935 VisitOverloadExpr(E);
1936 Record.push_back(E->isArrow());
1937 Record.push_back(E->hasUnresolvedUsing());
1938 Record.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr);
1939 Record.AddTypeRef(E->getBaseType());
1940 Record.AddSourceLocation(E->getOperatorLoc());
1941 Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1942 }
1943
VisitUnresolvedLookupExpr(UnresolvedLookupExpr * E)1944 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1945 VisitOverloadExpr(E);
1946 Record.push_back(E->requiresADL());
1947 Record.push_back(E->isOverloaded());
1948 Record.AddDeclRef(E->getNamingClass());
1949 Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1950 }
1951
VisitTypeTraitExpr(TypeTraitExpr * E)1952 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1953 VisitExpr(E);
1954 Record.push_back(E->TypeTraitExprBits.NumArgs);
1955 Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
1956 Record.push_back(E->TypeTraitExprBits.Value);
1957 Record.AddSourceRange(E->getSourceRange());
1958 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1959 Record.AddTypeSourceInfo(E->getArg(I));
1960 Code = serialization::EXPR_TYPE_TRAIT;
1961 }
1962
VisitArrayTypeTraitExpr(ArrayTypeTraitExpr * E)1963 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1964 VisitExpr(E);
1965 Record.push_back(E->getTrait());
1966 Record.push_back(E->getValue());
1967 Record.AddSourceRange(E->getSourceRange());
1968 Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo());
1969 Record.AddStmt(E->getDimensionExpression());
1970 Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1971 }
1972
VisitExpressionTraitExpr(ExpressionTraitExpr * E)1973 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1974 VisitExpr(E);
1975 Record.push_back(E->getTrait());
1976 Record.push_back(E->getValue());
1977 Record.AddSourceRange(E->getSourceRange());
1978 Record.AddStmt(E->getQueriedExpression());
1979 Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1980 }
1981
VisitCXXNoexceptExpr(CXXNoexceptExpr * E)1982 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1983 VisitExpr(E);
1984 Record.push_back(E->getValue());
1985 Record.AddSourceRange(E->getSourceRange());
1986 Record.AddStmt(E->getOperand());
1987 Code = serialization::EXPR_CXX_NOEXCEPT;
1988 }
1989
VisitPackExpansionExpr(PackExpansionExpr * E)1990 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1991 VisitExpr(E);
1992 Record.AddSourceLocation(E->getEllipsisLoc());
1993 Record.push_back(E->NumExpansions);
1994 Record.AddStmt(E->getPattern());
1995 Code = serialization::EXPR_PACK_EXPANSION;
1996 }
1997
VisitSizeOfPackExpr(SizeOfPackExpr * E)1998 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1999 VisitExpr(E);
2000 Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()
2001 : 0);
2002 Record.AddSourceLocation(E->OperatorLoc);
2003 Record.AddSourceLocation(E->PackLoc);
2004 Record.AddSourceLocation(E->RParenLoc);
2005 Record.AddDeclRef(E->Pack);
2006 if (E->isPartiallySubstituted()) {
2007 for (const auto &TA : E->getPartialArguments())
2008 Record.AddTemplateArgument(TA);
2009 } else if (!E->isValueDependent()) {
2010 Record.push_back(E->getPackLength());
2011 }
2012 Code = serialization::EXPR_SIZEOF_PACK;
2013 }
2014
VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr * E)2015 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
2016 SubstNonTypeTemplateParmExpr *E) {
2017 VisitExpr(E);
2018 Record.AddDeclRef(E->getParameter());
2019 Record.AddSourceLocation(E->getNameLoc());
2020 Record.AddStmt(E->getReplacement());
2021 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
2022 }
2023
VisitSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr * E)2024 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
2025 SubstNonTypeTemplateParmPackExpr *E) {
2026 VisitExpr(E);
2027 Record.AddDeclRef(E->getParameterPack());
2028 Record.AddTemplateArgument(E->getArgumentPack());
2029 Record.AddSourceLocation(E->getParameterPackLocation());
2030 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
2031 }
2032
VisitFunctionParmPackExpr(FunctionParmPackExpr * E)2033 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2034 VisitExpr(E);
2035 Record.push_back(E->getNumExpansions());
2036 Record.AddDeclRef(E->getParameterPack());
2037 Record.AddSourceLocation(E->getParameterPackLocation());
2038 for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
2039 I != End; ++I)
2040 Record.AddDeclRef(*I);
2041 Code = serialization::EXPR_FUNCTION_PARM_PACK;
2042 }
2043
VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr * E)2044 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2045 VisitExpr(E);
2046 Record.push_back(static_cast<bool>(E->getLifetimeExtendedTemporaryDecl()));
2047 if (E->getLifetimeExtendedTemporaryDecl())
2048 Record.AddDeclRef(E->getLifetimeExtendedTemporaryDecl());
2049 else
2050 Record.AddStmt(E->getSubExpr());
2051 Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
2052 }
2053
VisitCXXFoldExpr(CXXFoldExpr * E)2054 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
2055 VisitExpr(E);
2056 Record.AddSourceLocation(E->LParenLoc);
2057 Record.AddSourceLocation(E->EllipsisLoc);
2058 Record.AddSourceLocation(E->RParenLoc);
2059 Record.push_back(E->NumExpansions);
2060 Record.AddStmt(E->SubExprs[0]);
2061 Record.AddStmt(E->SubExprs[1]);
2062 Record.push_back(E->Opcode);
2063 Code = serialization::EXPR_CXX_FOLD;
2064 }
2065
VisitOpaqueValueExpr(OpaqueValueExpr * E)2066 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2067 VisitExpr(E);
2068 Record.AddStmt(E->getSourceExpr());
2069 Record.AddSourceLocation(E->getLocation());
2070 Record.push_back(E->isUnique());
2071 Code = serialization::EXPR_OPAQUE_VALUE;
2072 }
2073
VisitTypoExpr(TypoExpr * E)2074 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
2075 VisitExpr(E);
2076 // TODO: Figure out sane writer behavior for a TypoExpr, if necessary
2077 llvm_unreachable("Cannot write TypoExpr nodes");
2078 }
2079
2080 //===----------------------------------------------------------------------===//
2081 // CUDA Expressions and Statements.
2082 //===----------------------------------------------------------------------===//
2083
VisitCUDAKernelCallExpr(CUDAKernelCallExpr * E)2084 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2085 VisitCallExpr(E);
2086 Record.AddStmt(E->getConfig());
2087 Code = serialization::EXPR_CUDA_KERNEL_CALL;
2088 }
2089
2090 //===----------------------------------------------------------------------===//
2091 // OpenCL Expressions and Statements.
2092 //===----------------------------------------------------------------------===//
VisitAsTypeExpr(AsTypeExpr * E)2093 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
2094 VisitExpr(E);
2095 Record.AddSourceLocation(E->getBuiltinLoc());
2096 Record.AddSourceLocation(E->getRParenLoc());
2097 Record.AddStmt(E->getSrcExpr());
2098 Code = serialization::EXPR_ASTYPE;
2099 }
2100
2101 //===----------------------------------------------------------------------===//
2102 // Microsoft Expressions and Statements.
2103 //===----------------------------------------------------------------------===//
VisitMSPropertyRefExpr(MSPropertyRefExpr * E)2104 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2105 VisitExpr(E);
2106 Record.push_back(E->isArrow());
2107 Record.AddStmt(E->getBaseExpr());
2108 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2109 Record.AddSourceLocation(E->getMemberLoc());
2110 Record.AddDeclRef(E->getPropertyDecl());
2111 Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR;
2112 }
2113
VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr * E)2114 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2115 VisitExpr(E);
2116 Record.AddStmt(E->getBase());
2117 Record.AddStmt(E->getIdx());
2118 Record.AddSourceLocation(E->getRBracketLoc());
2119 Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR;
2120 }
2121
VisitCXXUuidofExpr(CXXUuidofExpr * E)2122 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2123 VisitExpr(E);
2124 Record.AddSourceRange(E->getSourceRange());
2125 Record.AddDeclRef(E->getGuidDecl());
2126 if (E->isTypeOperand()) {
2127 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
2128 Code = serialization::EXPR_CXX_UUIDOF_TYPE;
2129 } else {
2130 Record.AddStmt(E->getExprOperand());
2131 Code = serialization::EXPR_CXX_UUIDOF_EXPR;
2132 }
2133 }
2134
VisitSEHExceptStmt(SEHExceptStmt * S)2135 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
2136 VisitStmt(S);
2137 Record.AddSourceLocation(S->getExceptLoc());
2138 Record.AddStmt(S->getFilterExpr());
2139 Record.AddStmt(S->getBlock());
2140 Code = serialization::STMT_SEH_EXCEPT;
2141 }
2142
VisitSEHFinallyStmt(SEHFinallyStmt * S)2143 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
2144 VisitStmt(S);
2145 Record.AddSourceLocation(S->getFinallyLoc());
2146 Record.AddStmt(S->getBlock());
2147 Code = serialization::STMT_SEH_FINALLY;
2148 }
2149
VisitSEHTryStmt(SEHTryStmt * S)2150 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
2151 VisitStmt(S);
2152 Record.push_back(S->getIsCXXTry());
2153 Record.AddSourceLocation(S->getTryLoc());
2154 Record.AddStmt(S->getTryBlock());
2155 Record.AddStmt(S->getHandler());
2156 Code = serialization::STMT_SEH_TRY;
2157 }
2158
VisitSEHLeaveStmt(SEHLeaveStmt * S)2159 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
2160 VisitStmt(S);
2161 Record.AddSourceLocation(S->getLeaveLoc());
2162 Code = serialization::STMT_SEH_LEAVE;
2163 }
2164
2165 //===----------------------------------------------------------------------===//
2166 // OpenMP Directives.
2167 //===----------------------------------------------------------------------===//
VisitOMPExecutableDirective(OMPExecutableDirective * E)2168 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2169 Record.AddSourceLocation(E->getBeginLoc());
2170 Record.AddSourceLocation(E->getEndLoc());
2171 for (unsigned i = 0; i < E->getNumClauses(); ++i) {
2172 Record.writeOMPClause(E->getClause(i));
2173 }
2174 if (E->hasAssociatedStmt())
2175 Record.AddStmt(E->getAssociatedStmt());
2176 }
2177
VisitOMPLoopDirective(OMPLoopDirective * D)2178 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
2179 VisitStmt(D);
2180 Record.push_back(D->getNumClauses());
2181 Record.push_back(D->getCollapsedNumber());
2182 VisitOMPExecutableDirective(D);
2183 Record.AddStmt(D->getIterationVariable());
2184 Record.AddStmt(D->getLastIteration());
2185 Record.AddStmt(D->getCalcLastIteration());
2186 Record.AddStmt(D->getPreCond());
2187 Record.AddStmt(D->getCond());
2188 Record.AddStmt(D->getInit());
2189 Record.AddStmt(D->getInc());
2190 Record.AddStmt(D->getPreInits());
2191 if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
2192 isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
2193 isOpenMPDistributeDirective(D->getDirectiveKind())) {
2194 Record.AddStmt(D->getIsLastIterVariable());
2195 Record.AddStmt(D->getLowerBoundVariable());
2196 Record.AddStmt(D->getUpperBoundVariable());
2197 Record.AddStmt(D->getStrideVariable());
2198 Record.AddStmt(D->getEnsureUpperBound());
2199 Record.AddStmt(D->getNextLowerBound());
2200 Record.AddStmt(D->getNextUpperBound());
2201 Record.AddStmt(D->getNumIterations());
2202 }
2203 if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
2204 Record.AddStmt(D->getPrevLowerBoundVariable());
2205 Record.AddStmt(D->getPrevUpperBoundVariable());
2206 Record.AddStmt(D->getDistInc());
2207 Record.AddStmt(D->getPrevEnsureUpperBound());
2208 Record.AddStmt(D->getCombinedLowerBoundVariable());
2209 Record.AddStmt(D->getCombinedUpperBoundVariable());
2210 Record.AddStmt(D->getCombinedEnsureUpperBound());
2211 Record.AddStmt(D->getCombinedInit());
2212 Record.AddStmt(D->getCombinedCond());
2213 Record.AddStmt(D->getCombinedNextLowerBound());
2214 Record.AddStmt(D->getCombinedNextUpperBound());
2215 Record.AddStmt(D->getCombinedDistCond());
2216 Record.AddStmt(D->getCombinedParForInDistCond());
2217 }
2218 for (auto I : D->counters()) {
2219 Record.AddStmt(I);
2220 }
2221 for (auto I : D->private_counters()) {
2222 Record.AddStmt(I);
2223 }
2224 for (auto I : D->inits()) {
2225 Record.AddStmt(I);
2226 }
2227 for (auto I : D->updates()) {
2228 Record.AddStmt(I);
2229 }
2230 for (auto I : D->finals()) {
2231 Record.AddStmt(I);
2232 }
2233 for (Stmt *S : D->dependent_counters())
2234 Record.AddStmt(S);
2235 for (Stmt *S : D->dependent_inits())
2236 Record.AddStmt(S);
2237 for (Stmt *S : D->finals_conditions())
2238 Record.AddStmt(S);
2239 }
2240
VisitOMPParallelDirective(OMPParallelDirective * D)2241 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
2242 VisitStmt(D);
2243 Record.push_back(D->getNumClauses());
2244 VisitOMPExecutableDirective(D);
2245 Record.AddStmt(D->getTaskReductionRefExpr());
2246 Record.push_back(D->hasCancel() ? 1 : 0);
2247 Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
2248 }
2249
VisitOMPSimdDirective(OMPSimdDirective * D)2250 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
2251 VisitOMPLoopDirective(D);
2252 Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
2253 }
2254
VisitOMPForDirective(OMPForDirective * D)2255 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
2256 VisitOMPLoopDirective(D);
2257 Record.AddStmt(D->getTaskReductionRefExpr());
2258 Record.push_back(D->hasCancel() ? 1 : 0);
2259 Code = serialization::STMT_OMP_FOR_DIRECTIVE;
2260 }
2261
VisitOMPForSimdDirective(OMPForSimdDirective * D)2262 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2263 VisitOMPLoopDirective(D);
2264 Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE;
2265 }
2266
VisitOMPSectionsDirective(OMPSectionsDirective * D)2267 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2268 VisitStmt(D);
2269 Record.push_back(D->getNumClauses());
2270 VisitOMPExecutableDirective(D);
2271 Record.AddStmt(D->getTaskReductionRefExpr());
2272 Record.push_back(D->hasCancel() ? 1 : 0);
2273 Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
2274 }
2275
VisitOMPSectionDirective(OMPSectionDirective * D)2276 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
2277 VisitStmt(D);
2278 VisitOMPExecutableDirective(D);
2279 Record.push_back(D->hasCancel() ? 1 : 0);
2280 Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
2281 }
2282
VisitOMPSingleDirective(OMPSingleDirective * D)2283 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
2284 VisitStmt(D);
2285 Record.push_back(D->getNumClauses());
2286 VisitOMPExecutableDirective(D);
2287 Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
2288 }
2289
VisitOMPMasterDirective(OMPMasterDirective * D)2290 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
2291 VisitStmt(D);
2292 VisitOMPExecutableDirective(D);
2293 Code = serialization::STMT_OMP_MASTER_DIRECTIVE;
2294 }
2295
VisitOMPCriticalDirective(OMPCriticalDirective * D)2296 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2297 VisitStmt(D);
2298 Record.push_back(D->getNumClauses());
2299 VisitOMPExecutableDirective(D);
2300 Record.AddDeclarationNameInfo(D->getDirectiveName());
2301 Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
2302 }
2303
VisitOMPParallelForDirective(OMPParallelForDirective * D)2304 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2305 VisitOMPLoopDirective(D);
2306 Record.AddStmt(D->getTaskReductionRefExpr());
2307 Record.push_back(D->hasCancel() ? 1 : 0);
2308 Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
2309 }
2310
VisitOMPParallelForSimdDirective(OMPParallelForSimdDirective * D)2311 void ASTStmtWriter::VisitOMPParallelForSimdDirective(
2312 OMPParallelForSimdDirective *D) {
2313 VisitOMPLoopDirective(D);
2314 Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
2315 }
2316
VisitOMPParallelMasterDirective(OMPParallelMasterDirective * D)2317 void ASTStmtWriter::VisitOMPParallelMasterDirective(
2318 OMPParallelMasterDirective *D) {
2319 VisitStmt(D);
2320 Record.push_back(D->getNumClauses());
2321 VisitOMPExecutableDirective(D);
2322 Record.AddStmt(D->getTaskReductionRefExpr());
2323 Code = serialization::STMT_OMP_PARALLEL_MASTER_DIRECTIVE;
2324 }
2325
VisitOMPParallelSectionsDirective(OMPParallelSectionsDirective * D)2326 void ASTStmtWriter::VisitOMPParallelSectionsDirective(
2327 OMPParallelSectionsDirective *D) {
2328 VisitStmt(D);
2329 Record.push_back(D->getNumClauses());
2330 VisitOMPExecutableDirective(D);
2331 Record.AddStmt(D->getTaskReductionRefExpr());
2332 Record.push_back(D->hasCancel() ? 1 : 0);
2333 Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
2334 }
2335
VisitOMPTaskDirective(OMPTaskDirective * D)2336 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
2337 VisitStmt(D);
2338 Record.push_back(D->getNumClauses());
2339 VisitOMPExecutableDirective(D);
2340 Record.push_back(D->hasCancel() ? 1 : 0);
2341 Code = serialization::STMT_OMP_TASK_DIRECTIVE;
2342 }
2343
VisitOMPAtomicDirective(OMPAtomicDirective * D)2344 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2345 VisitStmt(D);
2346 Record.push_back(D->getNumClauses());
2347 VisitOMPExecutableDirective(D);
2348 Record.AddStmt(D->getX());
2349 Record.AddStmt(D->getV());
2350 Record.AddStmt(D->getExpr());
2351 Record.AddStmt(D->getUpdateExpr());
2352 Record.push_back(D->isXLHSInRHSPart() ? 1 : 0);
2353 Record.push_back(D->isPostfixUpdate() ? 1 : 0);
2354 Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
2355 }
2356
VisitOMPTargetDirective(OMPTargetDirective * D)2357 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
2358 VisitStmt(D);
2359 Record.push_back(D->getNumClauses());
2360 VisitOMPExecutableDirective(D);
2361 Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
2362 }
2363
VisitOMPTargetDataDirective(OMPTargetDataDirective * D)2364 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2365 VisitStmt(D);
2366 Record.push_back(D->getNumClauses());
2367 VisitOMPExecutableDirective(D);
2368 Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE;
2369 }
2370
VisitOMPTargetEnterDataDirective(OMPTargetEnterDataDirective * D)2371 void ASTStmtWriter::VisitOMPTargetEnterDataDirective(
2372 OMPTargetEnterDataDirective *D) {
2373 VisitStmt(D);
2374 Record.push_back(D->getNumClauses());
2375 VisitOMPExecutableDirective(D);
2376 Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE;
2377 }
2378
VisitOMPTargetExitDataDirective(OMPTargetExitDataDirective * D)2379 void ASTStmtWriter::VisitOMPTargetExitDataDirective(
2380 OMPTargetExitDataDirective *D) {
2381 VisitStmt(D);
2382 Record.push_back(D->getNumClauses());
2383 VisitOMPExecutableDirective(D);
2384 Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE;
2385 }
2386
VisitOMPTargetParallelDirective(OMPTargetParallelDirective * D)2387 void ASTStmtWriter::VisitOMPTargetParallelDirective(
2388 OMPTargetParallelDirective *D) {
2389 VisitStmt(D);
2390 Record.push_back(D->getNumClauses());
2391 VisitOMPExecutableDirective(D);
2392 Record.AddStmt(D->getTaskReductionRefExpr());
2393 Record.writeBool(D->hasCancel());
2394 Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE;
2395 }
2396
VisitOMPTargetParallelForDirective(OMPTargetParallelForDirective * D)2397 void ASTStmtWriter::VisitOMPTargetParallelForDirective(
2398 OMPTargetParallelForDirective *D) {
2399 VisitOMPLoopDirective(D);
2400 Record.AddStmt(D->getTaskReductionRefExpr());
2401 Record.push_back(D->hasCancel() ? 1 : 0);
2402 Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE;
2403 }
2404
VisitOMPTaskyieldDirective(OMPTaskyieldDirective * D)2405 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2406 VisitStmt(D);
2407 VisitOMPExecutableDirective(D);
2408 Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
2409 }
2410
VisitOMPBarrierDirective(OMPBarrierDirective * D)2411 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2412 VisitStmt(D);
2413 VisitOMPExecutableDirective(D);
2414 Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
2415 }
2416
VisitOMPTaskwaitDirective(OMPTaskwaitDirective * D)2417 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2418 VisitStmt(D);
2419 VisitOMPExecutableDirective(D);
2420 Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
2421 }
2422
VisitOMPTaskgroupDirective(OMPTaskgroupDirective * D)2423 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2424 VisitStmt(D);
2425 Record.push_back(D->getNumClauses());
2426 VisitOMPExecutableDirective(D);
2427 Record.AddStmt(D->getReductionRef());
2428 Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE;
2429 }
2430
VisitOMPFlushDirective(OMPFlushDirective * D)2431 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
2432 VisitStmt(D);
2433 Record.push_back(D->getNumClauses());
2434 VisitOMPExecutableDirective(D);
2435 Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
2436 }
2437
VisitOMPDepobjDirective(OMPDepobjDirective * D)2438 void ASTStmtWriter::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2439 VisitStmt(D);
2440 Record.push_back(D->getNumClauses());
2441 VisitOMPExecutableDirective(D);
2442 Code = serialization::STMT_OMP_DEPOBJ_DIRECTIVE;
2443 }
2444
VisitOMPScanDirective(OMPScanDirective * D)2445 void ASTStmtWriter::VisitOMPScanDirective(OMPScanDirective *D) {
2446 VisitStmt(D);
2447 Record.push_back(D->getNumClauses());
2448 VisitOMPExecutableDirective(D);
2449 Code = serialization::STMT_OMP_SCAN_DIRECTIVE;
2450 }
2451
VisitOMPOrderedDirective(OMPOrderedDirective * D)2452 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2453 VisitStmt(D);
2454 Record.push_back(D->getNumClauses());
2455 VisitOMPExecutableDirective(D);
2456 Code = serialization::STMT_OMP_ORDERED_DIRECTIVE;
2457 }
2458
VisitOMPTeamsDirective(OMPTeamsDirective * D)2459 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2460 VisitStmt(D);
2461 Record.push_back(D->getNumClauses());
2462 VisitOMPExecutableDirective(D);
2463 Code = serialization::STMT_OMP_TEAMS_DIRECTIVE;
2464 }
2465
VisitOMPCancellationPointDirective(OMPCancellationPointDirective * D)2466 void ASTStmtWriter::VisitOMPCancellationPointDirective(
2467 OMPCancellationPointDirective *D) {
2468 VisitStmt(D);
2469 VisitOMPExecutableDirective(D);
2470 Record.push_back(uint64_t(D->getCancelRegion()));
2471 Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
2472 }
2473
VisitOMPCancelDirective(OMPCancelDirective * D)2474 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
2475 VisitStmt(D);
2476 Record.push_back(D->getNumClauses());
2477 VisitOMPExecutableDirective(D);
2478 Record.push_back(uint64_t(D->getCancelRegion()));
2479 Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
2480 }
2481
VisitOMPTaskLoopDirective(OMPTaskLoopDirective * D)2482 void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2483 VisitOMPLoopDirective(D);
2484 Record.push_back(D->hasCancel() ? 1 : 0);
2485 Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE;
2486 }
2487
VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective * D)2488 void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2489 VisitOMPLoopDirective(D);
2490 Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE;
2491 }
2492
VisitOMPMasterTaskLoopDirective(OMPMasterTaskLoopDirective * D)2493 void ASTStmtWriter::VisitOMPMasterTaskLoopDirective(
2494 OMPMasterTaskLoopDirective *D) {
2495 VisitOMPLoopDirective(D);
2496 Record.push_back(D->hasCancel() ? 1 : 0);
2497 Code = serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE;
2498 }
2499
VisitOMPMasterTaskLoopSimdDirective(OMPMasterTaskLoopSimdDirective * D)2500 void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(
2501 OMPMasterTaskLoopSimdDirective *D) {
2502 VisitOMPLoopDirective(D);
2503 Code = serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE;
2504 }
2505
VisitOMPParallelMasterTaskLoopDirective(OMPParallelMasterTaskLoopDirective * D)2506 void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective(
2507 OMPParallelMasterTaskLoopDirective *D) {
2508 VisitOMPLoopDirective(D);
2509 Record.push_back(D->hasCancel() ? 1 : 0);
2510 Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE;
2511 }
2512
VisitOMPParallelMasterTaskLoopSimdDirective(OMPParallelMasterTaskLoopSimdDirective * D)2513 void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective(
2514 OMPParallelMasterTaskLoopSimdDirective *D) {
2515 VisitOMPLoopDirective(D);
2516 Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE;
2517 }
2518
VisitOMPDistributeDirective(OMPDistributeDirective * D)2519 void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2520 VisitOMPLoopDirective(D);
2521 Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE;
2522 }
2523
VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective * D)2524 void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2525 VisitStmt(D);
2526 Record.push_back(D->getNumClauses());
2527 VisitOMPExecutableDirective(D);
2528 Code = serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE;
2529 }
2530
VisitOMPDistributeParallelForDirective(OMPDistributeParallelForDirective * D)2531 void ASTStmtWriter::VisitOMPDistributeParallelForDirective(
2532 OMPDistributeParallelForDirective *D) {
2533 VisitOMPLoopDirective(D);
2534 Record.AddStmt(D->getTaskReductionRefExpr());
2535 Record.push_back(D->hasCancel() ? 1 : 0);
2536 Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2537 }
2538
VisitOMPDistributeParallelForSimdDirective(OMPDistributeParallelForSimdDirective * D)2539 void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective(
2540 OMPDistributeParallelForSimdDirective *D) {
2541 VisitOMPLoopDirective(D);
2542 Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2543 }
2544
VisitOMPDistributeSimdDirective(OMPDistributeSimdDirective * D)2545 void ASTStmtWriter::VisitOMPDistributeSimdDirective(
2546 OMPDistributeSimdDirective *D) {
2547 VisitOMPLoopDirective(D);
2548 Code = serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE;
2549 }
2550
VisitOMPTargetParallelForSimdDirective(OMPTargetParallelForSimdDirective * D)2551 void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective(
2552 OMPTargetParallelForSimdDirective *D) {
2553 VisitOMPLoopDirective(D);
2554 Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE;
2555 }
2556
VisitOMPTargetSimdDirective(OMPTargetSimdDirective * D)2557 void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2558 VisitOMPLoopDirective(D);
2559 Code = serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE;
2560 }
2561
VisitOMPTeamsDistributeDirective(OMPTeamsDistributeDirective * D)2562 void ASTStmtWriter::VisitOMPTeamsDistributeDirective(
2563 OMPTeamsDistributeDirective *D) {
2564 VisitOMPLoopDirective(D);
2565 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE;
2566 }
2567
VisitOMPTeamsDistributeSimdDirective(OMPTeamsDistributeSimdDirective * D)2568 void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective(
2569 OMPTeamsDistributeSimdDirective *D) {
2570 VisitOMPLoopDirective(D);
2571 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
2572 }
2573
VisitOMPTeamsDistributeParallelForSimdDirective(OMPTeamsDistributeParallelForSimdDirective * D)2574 void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective(
2575 OMPTeamsDistributeParallelForSimdDirective *D) {
2576 VisitOMPLoopDirective(D);
2577 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2578 }
2579
VisitOMPTeamsDistributeParallelForDirective(OMPTeamsDistributeParallelForDirective * D)2580 void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective(
2581 OMPTeamsDistributeParallelForDirective *D) {
2582 VisitOMPLoopDirective(D);
2583 Record.AddStmt(D->getTaskReductionRefExpr());
2584 Record.push_back(D->hasCancel() ? 1 : 0);
2585 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2586 }
2587
VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective * D)2588 void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2589 VisitStmt(D);
2590 Record.push_back(D->getNumClauses());
2591 VisitOMPExecutableDirective(D);
2592 Code = serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE;
2593 }
2594
VisitOMPTargetTeamsDistributeDirective(OMPTargetTeamsDistributeDirective * D)2595 void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective(
2596 OMPTargetTeamsDistributeDirective *D) {
2597 VisitOMPLoopDirective(D);
2598 Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE;
2599 }
2600
VisitOMPTargetTeamsDistributeParallelForDirective(OMPTargetTeamsDistributeParallelForDirective * D)2601 void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective(
2602 OMPTargetTeamsDistributeParallelForDirective *D) {
2603 VisitOMPLoopDirective(D);
2604 Record.AddStmt(D->getTaskReductionRefExpr());
2605 Record.push_back(D->hasCancel() ? 1 : 0);
2606 Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2607 }
2608
VisitOMPTargetTeamsDistributeParallelForSimdDirective(OMPTargetTeamsDistributeParallelForSimdDirective * D)2609 void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2610 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2611 VisitOMPLoopDirective(D);
2612 Code = serialization::
2613 STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2614 }
2615
VisitOMPTargetTeamsDistributeSimdDirective(OMPTargetTeamsDistributeSimdDirective * D)2616 void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective(
2617 OMPTargetTeamsDistributeSimdDirective *D) {
2618 VisitOMPLoopDirective(D);
2619 Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
2620 }
2621
2622 //===----------------------------------------------------------------------===//
2623 // ASTWriter Implementation
2624 //===----------------------------------------------------------------------===//
2625
RecordSwitchCaseID(SwitchCase * S)2626 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
2627 assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
2628 "SwitchCase recorded twice");
2629 unsigned NextID = SwitchCaseIDs.size();
2630 SwitchCaseIDs[S] = NextID;
2631 return NextID;
2632 }
2633
getSwitchCaseID(SwitchCase * S)2634 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
2635 assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
2636 "SwitchCase hasn't been seen yet");
2637 return SwitchCaseIDs[S];
2638 }
2639
ClearSwitchCaseIDs()2640 void ASTWriter::ClearSwitchCaseIDs() {
2641 SwitchCaseIDs.clear();
2642 }
2643
2644 /// Write the given substatement or subexpression to the
2645 /// bitstream.
WriteSubStmt(Stmt * S)2646 void ASTWriter::WriteSubStmt(Stmt *S) {
2647 RecordData Record;
2648 ASTStmtWriter Writer(*this, Record);
2649 ++NumStatements;
2650
2651 if (!S) {
2652 Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
2653 return;
2654 }
2655
2656 llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
2657 if (I != SubStmtEntries.end()) {
2658 Record.push_back(I->second);
2659 Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
2660 return;
2661 }
2662
2663 #ifndef NDEBUG
2664 assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
2665
2666 struct ParentStmtInserterRAII {
2667 Stmt *S;
2668 llvm::DenseSet<Stmt *> &ParentStmts;
2669
2670 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
2671 : S(S), ParentStmts(ParentStmts) {
2672 ParentStmts.insert(S);
2673 }
2674 ~ParentStmtInserterRAII() {
2675 ParentStmts.erase(S);
2676 }
2677 };
2678
2679 ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
2680 #endif
2681
2682 Writer.Visit(S);
2683
2684 uint64_t Offset = Writer.Emit();
2685 SubStmtEntries[S] = Offset;
2686 }
2687
2688 /// Flush all of the statements that have been added to the
2689 /// queue via AddStmt().
FlushStmts()2690 void ASTRecordWriter::FlushStmts() {
2691 // We expect to be the only consumer of the two temporary statement maps,
2692 // assert that they are empty.
2693 assert(Writer->SubStmtEntries.empty() && "unexpected entries in sub-stmt map");
2694 assert(Writer->ParentStmts.empty() && "unexpected entries in parent stmt map");
2695
2696 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2697 Writer->WriteSubStmt(StmtsToEmit[I]);
2698
2699 assert(N == StmtsToEmit.size() && "record modified while being written!");
2700
2701 // Note that we are at the end of a full expression. Any
2702 // expression records that follow this one are part of a different
2703 // expression.
2704 Writer->Stream.EmitRecord(serialization::STMT_STOP, ArrayRef<uint32_t>());
2705
2706 Writer->SubStmtEntries.clear();
2707 Writer->ParentStmts.clear();
2708 }
2709
2710 StmtsToEmit.clear();
2711 }
2712
FlushSubStmts()2713 void ASTRecordWriter::FlushSubStmts() {
2714 // For a nested statement, write out the substatements in reverse order (so
2715 // that a simple stack machine can be used when loading), and don't emit a
2716 // STMT_STOP after each one.
2717 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2718 Writer->WriteSubStmt(StmtsToEmit[N - I - 1]);
2719 assert(N == StmtsToEmit.size() && "record modified while being written!");
2720 }
2721
2722 StmtsToEmit.clear();
2723 }
2724