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