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