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 Code = serialization::EXPR_INIT_LIST;
1254}
1255
1256void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1257 VisitExpr(E);
1258 Record.push_back(N: E->getNumSubExprs());
1259 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1260 Record.AddStmt(S: E->getSubExpr(Idx: I));
1261 Record.AddSourceLocation(Loc: E->getEqualOrColonLoc());
1262 Record.push_back(N: E->usesGNUSyntax());
1263 for (const DesignatedInitExpr::Designator &D : E->designators()) {
1264 if (D.isFieldDesignator()) {
1265 if (FieldDecl *Field = D.getFieldDecl()) {
1266 Record.push_back(N: serialization::DESIG_FIELD_DECL);
1267 Record.AddDeclRef(D: Field);
1268 } else {
1269 Record.push_back(N: serialization::DESIG_FIELD_NAME);
1270 Record.AddIdentifierRef(II: D.getFieldName());
1271 }
1272 Record.AddSourceLocation(Loc: D.getDotLoc());
1273 Record.AddSourceLocation(Loc: D.getFieldLoc());
1274 } else if (D.isArrayDesignator()) {
1275 Record.push_back(N: serialization::DESIG_ARRAY);
1276 Record.push_back(N: D.getArrayIndex());
1277 Record.AddSourceLocation(Loc: D.getLBracketLoc());
1278 Record.AddSourceLocation(Loc: D.getRBracketLoc());
1279 } else {
1280 assert(D.isArrayRangeDesignator() && "Unknown designator");
1281 Record.push_back(N: serialization::DESIG_ARRAY_RANGE);
1282 Record.push_back(N: D.getArrayIndex());
1283 Record.AddSourceLocation(Loc: D.getLBracketLoc());
1284 Record.AddSourceLocation(Loc: D.getEllipsisLoc());
1285 Record.AddSourceLocation(Loc: D.getRBracketLoc());
1286 }
1287 }
1288 Code = serialization::EXPR_DESIGNATED_INIT;
1289}
1290
1291void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1292 VisitExpr(E);
1293 Record.AddStmt(S: E->getBase());
1294 Record.AddStmt(S: E->getUpdater());
1295 Code = serialization::EXPR_DESIGNATED_INIT_UPDATE;
1296}
1297
1298void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
1299 VisitExpr(E);
1300 Code = serialization::EXPR_NO_INIT;
1301}
1302
1303void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1304 VisitExpr(E);
1305 Record.AddStmt(S: E->SubExprs[0]);
1306 Record.AddStmt(S: E->SubExprs[1]);
1307 Code = serialization::EXPR_ARRAY_INIT_LOOP;
1308}
1309
1310void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1311 VisitExpr(E);
1312 Code = serialization::EXPR_ARRAY_INIT_INDEX;
1313}
1314
1315void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1316 VisitExpr(E);
1317 Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
1318}
1319
1320void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
1321 VisitExpr(E);
1322 Record.AddStmt(S: E->getSubExpr());
1323 Record.AddTypeSourceInfo(TInfo: E->getWrittenTypeInfo());
1324 Record.AddSourceLocation(Loc: E->getBuiltinLoc());
1325 Record.AddSourceLocation(Loc: E->getRParenLoc());
1326 Record.push_back(N: E->isMicrosoftABI());
1327 Code = serialization::EXPR_VA_ARG;
1328}
1329
1330void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {
1331 VisitExpr(E);
1332 Record.AddDeclRef(D: cast_or_null<Decl>(Val: E->getParentContext()));
1333 Record.AddSourceLocation(Loc: E->getBeginLoc());
1334 Record.AddSourceLocation(Loc: E->getEndLoc());
1335 Record.push_back(N: llvm::to_underlying(E: E->getIdentKind()));
1336 Code = serialization::EXPR_SOURCE_LOC;
1337}
1338
1339void ASTStmtWriter::VisitEmbedExpr(EmbedExpr *E) {
1340 VisitExpr(E);
1341 Record.AddSourceLocation(Loc: E->getBeginLoc());
1342 Record.AddSourceLocation(Loc: E->getEndLoc());
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.AddSourceLocation(Loc: E->BeginLoc);
1774
1775 if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()) &&
1776 !E->isCoroElideSafe() && !E->usesMemberSyntax())
1777 AbbrevToUse = Writer.getCXXOperatorCallExprAbbrev();
1778
1779 Code = serialization::EXPR_CXX_OPERATOR_CALL;
1780}
1781
1782void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1783 VisitCallExpr(E);
1784
1785 if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()) &&
1786 !E->isCoroElideSafe() && !E->usesMemberSyntax())
1787 AbbrevToUse = Writer.getCXXMemberCallExprAbbrev();
1788
1789 Code = serialization::EXPR_CXX_MEMBER_CALL;
1790}
1791
1792void ASTStmtWriter::VisitCXXRewrittenBinaryOperator(
1793 CXXRewrittenBinaryOperator *E) {
1794 VisitExpr(E);
1795 Record.push_back(N: E->isReversed());
1796 Record.AddStmt(S: E->getSemanticForm());
1797 Code = serialization::EXPR_CXX_REWRITTEN_BINARY_OPERATOR;
1798}
1799
1800void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1801 VisitExpr(E);
1802
1803 Record.push_back(N: E->getNumArgs());
1804 Record.push_back(N: E->isElidable());
1805 Record.push_back(N: E->hadMultipleCandidates());
1806 Record.push_back(N: E->isListInitialization());
1807 Record.push_back(N: E->isStdInitListInitialization());
1808 Record.push_back(N: E->requiresZeroInitialization());
1809 Record.push_back(
1810 N: llvm::to_underlying(E: E->getConstructionKind())); // FIXME: stable encoding
1811 Record.push_back(N: E->isImmediateEscalating());
1812 Record.AddSourceLocation(Loc: E->getLocation());
1813 Record.AddDeclRef(D: E->getConstructor());
1814 Record.AddSourceRange(Range: E->getParenOrBraceRange());
1815
1816 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1817 Record.AddStmt(S: E->getArg(Arg: I));
1818
1819 Code = serialization::EXPR_CXX_CONSTRUCT;
1820}
1821
1822void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1823 VisitExpr(E);
1824 Record.AddDeclRef(D: E->getConstructor());
1825 Record.AddSourceLocation(Loc: E->getLocation());
1826 Record.push_back(N: E->constructsVBase());
1827 Record.push_back(N: E->inheritedFromVBase());
1828 Code = serialization::EXPR_CXX_INHERITED_CTOR_INIT;
1829}
1830
1831void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1832 VisitCXXConstructExpr(E);
1833 Record.AddTypeSourceInfo(TInfo: E->getTypeSourceInfo());
1834 Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1835}
1836
1837void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1838 VisitExpr(E);
1839 Record.push_back(N: E->LambdaExprBits.NumCaptures);
1840 Record.AddSourceRange(Range: E->IntroducerRange);
1841 Record.push_back(N: E->LambdaExprBits.CaptureDefault); // FIXME: stable encoding
1842 Record.AddSourceLocation(Loc: E->CaptureDefaultLoc);
1843 Record.push_back(N: E->LambdaExprBits.ExplicitParams);
1844 Record.push_back(N: E->LambdaExprBits.ExplicitResultType);
1845 Record.AddSourceLocation(Loc: E->ClosingBrace);
1846
1847 // Add capture initializers.
1848 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1849 CEnd = E->capture_init_end();
1850 C != CEnd; ++C) {
1851 Record.AddStmt(S: *C);
1852 }
1853
1854 // Don't serialize the body. It belongs to the call operator declaration.
1855 // LambdaExpr only stores a copy of the Stmt *.
1856
1857 Code = serialization::EXPR_LAMBDA;
1858}
1859
1860void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1861 VisitExpr(E);
1862 Record.AddStmt(S: E->getSubExpr());
1863 Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST;
1864}
1865
1866void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1867 VisitExplicitCastExpr(E);
1868 Record.AddSourceRange(Range: SourceRange(E->getOperatorLoc(), E->getRParenLoc()));
1869 CurrentPackingBits.addBit(Value: E->getAngleBrackets().isValid());
1870 if (E->getAngleBrackets().isValid())
1871 Record.AddSourceRange(Range: E->getAngleBrackets());
1872}
1873
1874void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1875 VisitCXXNamedCastExpr(E);
1876 Code = serialization::EXPR_CXX_STATIC_CAST;
1877}
1878
1879void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1880 VisitCXXNamedCastExpr(E);
1881 Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1882}
1883
1884void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1885 VisitCXXNamedCastExpr(E);
1886 Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1887}
1888
1889void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1890 VisitCXXNamedCastExpr(E);
1891 Code = serialization::EXPR_CXX_CONST_CAST;
1892}
1893
1894void ASTStmtWriter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1895 VisitCXXNamedCastExpr(E);
1896 Code = serialization::EXPR_CXX_ADDRSPACE_CAST;
1897}
1898
1899void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1900 VisitExplicitCastExpr(E);
1901 Record.AddSourceLocation(Loc: E->getLParenLoc());
1902 Record.AddSourceLocation(Loc: E->getRParenLoc());
1903 Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1904}
1905
1906void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1907 VisitExplicitCastExpr(E);
1908 Record.AddSourceLocation(Loc: E->getBeginLoc());
1909 Record.AddSourceLocation(Loc: E->getEndLoc());
1910 Code = serialization::EXPR_BUILTIN_BIT_CAST;
1911}
1912
1913void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1914 VisitCallExpr(E);
1915 Record.AddSourceLocation(Loc: E->UDSuffixLoc);
1916 Code = serialization::EXPR_USER_DEFINED_LITERAL;
1917}
1918
1919void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1920 VisitExpr(E);
1921 Record.push_back(N: E->getValue());
1922 Record.AddSourceLocation(Loc: E->getLocation());
1923 Code = serialization::EXPR_CXX_BOOL_LITERAL;
1924}
1925
1926void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1927 VisitExpr(E);
1928 Record.AddSourceLocation(Loc: E->getLocation());
1929 Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1930}
1931
1932void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1933 VisitExpr(E);
1934 Record.AddSourceRange(Range: E->getSourceRange());
1935 if (E->isTypeOperand()) {
1936 Record.AddTypeSourceInfo(TInfo: E->getTypeOperandSourceInfo());
1937 Code = serialization::EXPR_CXX_TYPEID_TYPE;
1938 } else {
1939 Record.AddStmt(S: E->getExprOperand());
1940 Code = serialization::EXPR_CXX_TYPEID_EXPR;
1941 }
1942}
1943
1944void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1945 VisitExpr(E);
1946 Record.AddSourceLocation(Loc: E->getLocation());
1947 Record.push_back(N: E->isImplicit());
1948 Record.push_back(N: E->isCapturedByCopyInLambdaWithExplicitObjectParameter());
1949
1950 Code = serialization::EXPR_CXX_THIS;
1951}
1952
1953void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1954 VisitExpr(E);
1955 Record.AddSourceLocation(Loc: E->getThrowLoc());
1956 Record.AddStmt(S: E->getSubExpr());
1957 Record.push_back(N: E->isThrownVariableInScope());
1958 Code = serialization::EXPR_CXX_THROW;
1959}
1960
1961void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1962 VisitExpr(E);
1963 Record.AddDeclRef(D: E->getParam());
1964 Record.AddDeclRef(D: cast_or_null<Decl>(Val: E->getUsedContext()));
1965 Record.AddSourceLocation(Loc: E->getUsedLocation());
1966 Record.push_back(N: E->hasRewrittenInit());
1967 if (E->hasRewrittenInit())
1968 Record.AddStmt(S: E->getRewrittenExpr());
1969 Code = serialization::EXPR_CXX_DEFAULT_ARG;
1970}
1971
1972void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1973 VisitExpr(E);
1974 Record.push_back(N: E->hasRewrittenInit());
1975 Record.AddDeclRef(D: E->getField());
1976 Record.AddDeclRef(D: cast_or_null<Decl>(Val: E->getUsedContext()));
1977 Record.AddSourceLocation(Loc: E->getExprLoc());
1978 if (E->hasRewrittenInit())
1979 Record.AddStmt(S: E->getRewrittenExpr());
1980 Code = serialization::EXPR_CXX_DEFAULT_INIT;
1981}
1982
1983void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1984 VisitExpr(E);
1985 Record.AddCXXTemporary(Temp: E->getTemporary());
1986 Record.AddStmt(S: E->getSubExpr());
1987 Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1988}
1989
1990void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1991 VisitExpr(E);
1992 Record.AddTypeSourceInfo(TInfo: E->getTypeSourceInfo());
1993 Record.AddSourceLocation(Loc: E->getRParenLoc());
1994 Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1995}
1996
1997void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1998 VisitExpr(E);
1999
2000 Record.push_back(N: E->isArray());
2001 Record.push_back(N: E->hasInitializer());
2002 Record.push_back(N: E->getNumPlacementArgs());
2003 Record.push_back(N: E->isParenTypeId());
2004
2005 Record.push_back(N: E->isGlobalNew());
2006 ImplicitAllocationParameters IAP = E->implicitAllocationParameters();
2007 Record.push_back(N: isAlignedAllocation(Mode: IAP.PassAlignment));
2008 Record.push_back(N: isTypeAwareAllocation(Mode: IAP.PassTypeIdentity));
2009 Record.push_back(N: E->doesUsualArrayDeleteWantSize());
2010 Record.push_back(N: E->CXXNewExprBits.HasInitializer);
2011 Record.push_back(N: E->CXXNewExprBits.StoredInitializationStyle);
2012
2013 Record.AddDeclRef(D: E->getOperatorNew());
2014 Record.AddDeclRef(D: E->getOperatorDelete());
2015 Record.AddTypeSourceInfo(TInfo: E->getAllocatedTypeSourceInfo());
2016 if (E->isParenTypeId())
2017 Record.AddSourceRange(Range: E->getTypeIdParens());
2018 Record.AddSourceRange(Range: E->getSourceRange());
2019 Record.AddSourceRange(Range: E->getDirectInitRange());
2020
2021 for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), N = E->raw_arg_end();
2022 I != N; ++I)
2023 Record.AddStmt(S: *I);
2024
2025 Code = serialization::EXPR_CXX_NEW;
2026}
2027
2028void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
2029 VisitExpr(E);
2030 Record.push_back(N: E->isGlobalDelete());
2031 Record.push_back(N: E->isArrayForm());
2032 Record.push_back(N: E->isArrayFormAsWritten());
2033 Record.push_back(N: E->doesUsualArrayDeleteWantSize());
2034 Record.AddDeclRef(D: E->getOperatorDelete());
2035 Record.AddStmt(S: E->getArgument());
2036 Record.AddSourceLocation(Loc: E->getBeginLoc());
2037
2038 Code = serialization::EXPR_CXX_DELETE;
2039}
2040
2041void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
2042 VisitExpr(E);
2043
2044 Record.AddStmt(S: E->getBase());
2045 Record.push_back(N: E->isArrow());
2046 Record.AddSourceLocation(Loc: E->getOperatorLoc());
2047 Record.AddNestedNameSpecifierLoc(NNS: E->getQualifierLoc());
2048 Record.AddTypeSourceInfo(TInfo: E->getScopeTypeInfo());
2049 Record.AddSourceLocation(Loc: E->getColonColonLoc());
2050 Record.AddSourceLocation(Loc: E->getTildeLoc());
2051
2052 // PseudoDestructorTypeStorage.
2053 Record.AddIdentifierRef(II: E->getDestroyedTypeIdentifier());
2054 if (E->getDestroyedTypeIdentifier())
2055 Record.AddSourceLocation(Loc: E->getDestroyedTypeLoc());
2056 else
2057 Record.AddTypeSourceInfo(TInfo: E->getDestroyedTypeInfo());
2058
2059 Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
2060}
2061
2062void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
2063 VisitExpr(E);
2064 Record.push_back(N: E->getNumObjects());
2065 for (auto &Obj : E->getObjects()) {
2066 if (auto *BD = Obj.dyn_cast<BlockDecl *>()) {
2067 Record.push_back(N: serialization::COK_Block);
2068 Record.AddDeclRef(D: BD);
2069 } else if (auto *CLE = Obj.dyn_cast<CompoundLiteralExpr *>()) {
2070 Record.push_back(N: serialization::COK_CompoundLiteral);
2071 Record.AddStmt(S: CLE);
2072 }
2073 }
2074
2075 Record.push_back(N: E->cleanupsHaveSideEffects());
2076 Record.AddStmt(S: E->getSubExpr());
2077 Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
2078}
2079
2080void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(
2081 CXXDependentScopeMemberExpr *E) {
2082 VisitExpr(E);
2083
2084 // Don't emit anything here (or if you do you will have to update
2085 // the corresponding deserialization function).
2086 Record.push_back(N: E->getNumTemplateArgs());
2087 CurrentPackingBits.updateBits();
2088 CurrentPackingBits.addBit(Value: E->hasTemplateKWAndArgsInfo());
2089 CurrentPackingBits.addBit(Value: E->hasFirstQualifierFoundInScope());
2090
2091 if (E->hasTemplateKWAndArgsInfo()) {
2092 const ASTTemplateKWAndArgsInfo &ArgInfo =
2093 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
2094 AddTemplateKWAndArgsInfo(ArgInfo,
2095 Args: E->getTrailingObjects<TemplateArgumentLoc>());
2096 }
2097
2098 CurrentPackingBits.addBit(Value: E->isArrow());
2099
2100 Record.AddTypeRef(T: E->getBaseType());
2101 Record.AddNestedNameSpecifierLoc(NNS: E->getQualifierLoc());
2102 CurrentPackingBits.addBit(Value: !E->isImplicitAccess());
2103 if (!E->isImplicitAccess())
2104 Record.AddStmt(S: E->getBase());
2105
2106 Record.AddSourceLocation(Loc: E->getOperatorLoc());
2107
2108 if (E->hasFirstQualifierFoundInScope())
2109 Record.AddDeclRef(D: E->getFirstQualifierFoundInScope());
2110
2111 Record.AddDeclarationNameInfo(NameInfo: E->MemberNameInfo);
2112 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
2113}
2114
2115void
2116ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
2117 VisitExpr(E);
2118
2119 // Don't emit anything here, HasTemplateKWAndArgsInfo must be
2120 // emitted first.
2121 CurrentPackingBits.addBit(
2122 Value: E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo);
2123
2124 if (E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo) {
2125 const ASTTemplateKWAndArgsInfo &ArgInfo =
2126 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
2127 // 16 bits should be enought to store the number of args
2128 CurrentPackingBits.addBits(Value: ArgInfo.NumTemplateArgs, /*Width=*/BitsWidth: 16);
2129 AddTemplateKWAndArgsInfo(ArgInfo,
2130 Args: E->getTrailingObjects<TemplateArgumentLoc>());
2131 }
2132
2133 Record.AddNestedNameSpecifierLoc(NNS: E->getQualifierLoc());
2134 Record.AddDeclarationNameInfo(NameInfo: E->NameInfo);
2135 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
2136}
2137
2138void
2139ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
2140 VisitExpr(E);
2141 Record.push_back(N: E->getNumArgs());
2142 for (CXXUnresolvedConstructExpr::arg_iterator
2143 ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
2144 Record.AddStmt(S: *ArgI);
2145 Record.AddTypeSourceInfo(TInfo: E->getTypeSourceInfo());
2146 Record.AddSourceLocation(Loc: E->getLParenLoc());
2147 Record.AddSourceLocation(Loc: E->getRParenLoc());
2148 Record.push_back(N: E->isListInitialization());
2149 Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
2150}
2151
2152void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
2153 VisitExpr(E);
2154
2155 Record.push_back(N: E->getNumDecls());
2156
2157 CurrentPackingBits.updateBits();
2158 CurrentPackingBits.addBit(Value: E->hasTemplateKWAndArgsInfo());
2159 if (E->hasTemplateKWAndArgsInfo()) {
2160 const ASTTemplateKWAndArgsInfo &ArgInfo =
2161 *E->getTrailingASTTemplateKWAndArgsInfo();
2162 Record.push_back(N: ArgInfo.NumTemplateArgs);
2163 AddTemplateKWAndArgsInfo(ArgInfo, Args: E->getTrailingTemplateArgumentLoc());
2164 }
2165
2166 for (OverloadExpr::decls_iterator OvI = E->decls_begin(),
2167 OvE = E->decls_end();
2168 OvI != OvE; ++OvI) {
2169 Record.AddDeclRef(D: OvI.getDecl());
2170 Record.push_back(N: OvI.getAccess());
2171 }
2172
2173 Record.AddDeclarationNameInfo(NameInfo: E->getNameInfo());
2174 Record.AddNestedNameSpecifierLoc(NNS: E->getQualifierLoc());
2175}
2176
2177void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2178 VisitOverloadExpr(E);
2179 CurrentPackingBits.addBit(Value: E->isArrow());
2180 CurrentPackingBits.addBit(Value: E->hasUnresolvedUsing());
2181 CurrentPackingBits.addBit(Value: !E->isImplicitAccess());
2182 if (!E->isImplicitAccess())
2183 Record.AddStmt(S: E->getBase());
2184
2185 Record.AddSourceLocation(Loc: E->getOperatorLoc());
2186
2187 Record.AddTypeRef(T: E->getBaseType());
2188 Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
2189}
2190
2191void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2192 VisitOverloadExpr(E);
2193 CurrentPackingBits.addBit(Value: E->requiresADL());
2194 Record.AddDeclRef(D: E->getNamingClass());
2195 Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
2196
2197 if (Writer.isWritingStdCXXNamedModules() && Writer.getChain()) {
2198 // Referencing all the possible declarations to make sure the change get
2199 // propagted.
2200 DeclarationName Name = E->getName();
2201 for (auto *Found :
2202 Record.getASTContext().getTranslationUnitDecl()->lookup(Name))
2203 if (Found->isFromASTFile())
2204 Writer.GetDeclRef(D: Found);
2205
2206 llvm::SmallVector<NamespaceDecl *> ExternalNSs;
2207 Writer.getChain()->ReadKnownNamespaces(Namespaces&: ExternalNSs);
2208 for (auto *NS : ExternalNSs)
2209 for (auto *Found : NS->lookup(Name))
2210 Writer.GetDeclRef(D: Found);
2211 }
2212}
2213
2214void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
2215 VisitExpr(E);
2216 Record.push_back(N: E->TypeTraitExprBits.IsBooleanTypeTrait);
2217 Record.push_back(N: E->TypeTraitExprBits.NumArgs);
2218 Record.push_back(N: E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
2219
2220 if (E->TypeTraitExprBits.IsBooleanTypeTrait)
2221 Record.push_back(N: E->TypeTraitExprBits.Value);
2222 else
2223 Record.AddAPValue(Value: E->getAPValue());
2224
2225 Record.AddSourceRange(Range: E->getSourceRange());
2226 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2227 Record.AddTypeSourceInfo(TInfo: E->getArg(I));
2228 Code = serialization::EXPR_TYPE_TRAIT;
2229}
2230
2231void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2232 VisitExpr(E);
2233 Record.push_back(N: E->getTrait());
2234 Record.push_back(N: E->getValue());
2235 Record.AddSourceRange(Range: E->getSourceRange());
2236 Record.AddTypeSourceInfo(TInfo: E->getQueriedTypeSourceInfo());
2237 Record.AddStmt(S: E->getDimensionExpression());
2238 Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
2239}
2240
2241void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2242 VisitExpr(E);
2243 Record.push_back(N: E->getTrait());
2244 Record.push_back(N: E->getValue());
2245 Record.AddSourceRange(Range: E->getSourceRange());
2246 Record.AddStmt(S: E->getQueriedExpression());
2247 Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
2248}
2249
2250void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2251 VisitExpr(E);
2252 Record.push_back(N: E->getValue());
2253 Record.AddSourceRange(Range: E->getSourceRange());
2254 Record.AddStmt(S: E->getOperand());
2255 Code = serialization::EXPR_CXX_NOEXCEPT;
2256}
2257
2258void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
2259 VisitExpr(E);
2260 Record.AddSourceLocation(Loc: E->getEllipsisLoc());
2261 Record.push_back(N: E->NumExpansions);
2262 Record.AddStmt(S: E->getPattern());
2263 Code = serialization::EXPR_PACK_EXPANSION;
2264}
2265
2266void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2267 VisitExpr(E);
2268 Record.push_back(N: E->isPartiallySubstituted() ? E->getPartialArguments().size()
2269 : 0);
2270 Record.AddSourceLocation(Loc: E->OperatorLoc);
2271 Record.AddSourceLocation(Loc: E->PackLoc);
2272 Record.AddSourceLocation(Loc: E->RParenLoc);
2273 Record.AddDeclRef(D: E->Pack);
2274 if (E->isPartiallySubstituted()) {
2275 for (const auto &TA : E->getPartialArguments())
2276 Record.AddTemplateArgument(Arg: TA);
2277 } else if (!E->isValueDependent()) {
2278 Record.push_back(N: E->getPackLength());
2279 }
2280 Code = serialization::EXPR_SIZEOF_PACK;
2281}
2282
2283void ASTStmtWriter::VisitPackIndexingExpr(PackIndexingExpr *E) {
2284 VisitExpr(E);
2285 Record.push_back(N: E->PackIndexingExprBits.TransformedExpressions);
2286 Record.push_back(N: E->PackIndexingExprBits.FullySubstituted);
2287 Record.AddSourceLocation(Loc: E->getEllipsisLoc());
2288 Record.AddSourceLocation(Loc: E->getRSquareLoc());
2289 Record.AddStmt(S: E->getPackIdExpression());
2290 Record.AddStmt(S: E->getIndexExpr());
2291 for (Expr *Sub : E->getExpressions())
2292 Record.AddStmt(S: Sub);
2293 Code = serialization::EXPR_PACK_INDEXING;
2294}
2295
2296void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
2297 SubstNonTypeTemplateParmExpr *E) {
2298 VisitExpr(E);
2299 Record.AddDeclRef(D: E->getAssociatedDecl());
2300 CurrentPackingBits.addBit(Value: E->isReferenceParameter());
2301 CurrentPackingBits.addBits(Value: E->getIndex(), /*Width=*/BitsWidth: 12);
2302 Record.writeUnsignedOrNone(Value: E->getPackIndex());
2303 CurrentPackingBits.addBit(Value: E->getFinal());
2304
2305 Record.AddSourceLocation(Loc: E->getNameLoc());
2306 Record.AddStmt(S: E->getReplacement());
2307 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
2308}
2309
2310void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
2311 SubstNonTypeTemplateParmPackExpr *E) {
2312 VisitExpr(E);
2313 Record.AddDeclRef(D: E->getAssociatedDecl());
2314 CurrentPackingBits.addBit(Value: E->getFinal());
2315 Record.push_back(N: E->getIndex());
2316 Record.AddTemplateArgument(Arg: E->getArgumentPack());
2317 Record.AddSourceLocation(Loc: E->getParameterPackLocation());
2318 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
2319}
2320
2321void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2322 VisitExpr(E);
2323 Record.push_back(N: E->getNumExpansions());
2324 Record.AddDeclRef(D: E->getParameterPack());
2325 Record.AddSourceLocation(Loc: E->getParameterPackLocation());
2326 for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
2327 I != End; ++I)
2328 Record.AddDeclRef(D: *I);
2329 Code = serialization::EXPR_FUNCTION_PARM_PACK;
2330}
2331
2332void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2333 VisitExpr(E);
2334 Record.push_back(N: static_cast<bool>(E->getLifetimeExtendedTemporaryDecl()));
2335 if (E->getLifetimeExtendedTemporaryDecl())
2336 Record.AddDeclRef(D: E->getLifetimeExtendedTemporaryDecl());
2337 else
2338 Record.AddStmt(S: E->getSubExpr());
2339 Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
2340}
2341
2342void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
2343 VisitExpr(E);
2344 Record.AddSourceLocation(Loc: E->LParenLoc);
2345 Record.AddSourceLocation(Loc: E->EllipsisLoc);
2346 Record.AddSourceLocation(Loc: E->RParenLoc);
2347 Record.push_back(N: E->NumExpansions.toInternalRepresentation());
2348 Record.AddStmt(S: E->SubExprs[0]);
2349 Record.AddStmt(S: E->SubExprs[1]);
2350 Record.AddStmt(S: E->SubExprs[2]);
2351 Record.push_back(N: E->CXXFoldExprBits.Opcode);
2352 Code = serialization::EXPR_CXX_FOLD;
2353}
2354
2355void ASTStmtWriter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
2356 VisitExpr(E);
2357 ArrayRef<Expr *> InitExprs = E->getInitExprs();
2358 Record.push_back(N: InitExprs.size());
2359 Record.push_back(N: E->getUserSpecifiedInitExprs().size());
2360 Record.AddSourceLocation(Loc: E->getInitLoc());
2361 Record.AddSourceLocation(Loc: E->getBeginLoc());
2362 Record.AddSourceLocation(Loc: E->getEndLoc());
2363 for (Expr *InitExpr : E->getInitExprs())
2364 Record.AddStmt(S: InitExpr);
2365 Expr *ArrayFiller = E->getArrayFiller();
2366 FieldDecl *UnionField = E->getInitializedFieldInUnion();
2367 bool HasArrayFillerOrUnionDecl = ArrayFiller || UnionField;
2368 Record.push_back(N: HasArrayFillerOrUnionDecl);
2369 if (HasArrayFillerOrUnionDecl) {
2370 Record.push_back(N: static_cast<bool>(ArrayFiller));
2371 if (ArrayFiller)
2372 Record.AddStmt(S: ArrayFiller);
2373 else
2374 Record.AddDeclRef(D: UnionField);
2375 }
2376 Code = serialization::EXPR_CXX_PAREN_LIST_INIT;
2377}
2378
2379void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2380 VisitExpr(E);
2381 Record.AddStmt(S: E->getSourceExpr());
2382 Record.AddSourceLocation(Loc: E->getLocation());
2383 Record.push_back(N: E->isUnique());
2384 Code = serialization::EXPR_OPAQUE_VALUE;
2385}
2386
2387//===----------------------------------------------------------------------===//
2388// CUDA Expressions and Statements.
2389//===----------------------------------------------------------------------===//
2390
2391void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2392 VisitCallExpr(E);
2393 Record.AddStmt(S: E->getConfig());
2394 Code = serialization::EXPR_CUDA_KERNEL_CALL;
2395}
2396
2397//===----------------------------------------------------------------------===//
2398// OpenCL Expressions and Statements.
2399//===----------------------------------------------------------------------===//
2400void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
2401 VisitExpr(E);
2402 Record.AddSourceLocation(Loc: E->getBuiltinLoc());
2403 Record.AddSourceLocation(Loc: E->getRParenLoc());
2404 Record.AddStmt(S: E->getSrcExpr());
2405 Code = serialization::EXPR_ASTYPE;
2406}
2407
2408//===----------------------------------------------------------------------===//
2409// Microsoft Expressions and Statements.
2410//===----------------------------------------------------------------------===//
2411void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2412 VisitExpr(E);
2413 Record.push_back(N: E->isArrow());
2414 Record.AddStmt(S: E->getBaseExpr());
2415 Record.AddNestedNameSpecifierLoc(NNS: E->getQualifierLoc());
2416 Record.AddSourceLocation(Loc: E->getMemberLoc());
2417 Record.AddDeclRef(D: E->getPropertyDecl());
2418 Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR;
2419}
2420
2421void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2422 VisitExpr(E);
2423 Record.AddStmt(S: E->getBase());
2424 Record.AddStmt(S: E->getIdx());
2425 Record.AddSourceLocation(Loc: E->getRBracketLoc());
2426 Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR;
2427}
2428
2429void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2430 VisitExpr(E);
2431 Record.AddSourceRange(Range: E->getSourceRange());
2432 Record.AddDeclRef(D: E->getGuidDecl());
2433 if (E->isTypeOperand()) {
2434 Record.AddTypeSourceInfo(TInfo: E->getTypeOperandSourceInfo());
2435 Code = serialization::EXPR_CXX_UUIDOF_TYPE;
2436 } else {
2437 Record.AddStmt(S: E->getExprOperand());
2438 Code = serialization::EXPR_CXX_UUIDOF_EXPR;
2439 }
2440}
2441
2442void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
2443 VisitStmt(S);
2444 Record.AddSourceLocation(Loc: S->getExceptLoc());
2445 Record.AddStmt(S: S->getFilterExpr());
2446 Record.AddStmt(S: S->getBlock());
2447 Code = serialization::STMT_SEH_EXCEPT;
2448}
2449
2450void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
2451 VisitStmt(S);
2452 Record.AddSourceLocation(Loc: S->getFinallyLoc());
2453 Record.AddStmt(S: S->getBlock());
2454 Code = serialization::STMT_SEH_FINALLY;
2455}
2456
2457void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
2458 VisitStmt(S);
2459 Record.push_back(N: S->getIsCXXTry());
2460 Record.AddSourceLocation(Loc: S->getTryLoc());
2461 Record.AddStmt(S: S->getTryBlock());
2462 Record.AddStmt(S: S->getHandler());
2463 Code = serialization::STMT_SEH_TRY;
2464}
2465
2466void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
2467 VisitStmt(S);
2468 Record.AddSourceLocation(Loc: S->getLeaveLoc());
2469 Code = serialization::STMT_SEH_LEAVE;
2470}
2471
2472//===----------------------------------------------------------------------===//
2473// OpenMP Directives.
2474//===----------------------------------------------------------------------===//
2475
2476void ASTStmtWriter::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
2477 VisitStmt(S);
2478 for (Stmt *SubStmt : S->SubStmts)
2479 Record.AddStmt(S: SubStmt);
2480 Code = serialization::STMT_OMP_CANONICAL_LOOP;
2481}
2482
2483void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2484 Record.writeOMPChildren(Data: E->Data);
2485 Record.AddSourceLocation(Loc: E->getBeginLoc());
2486 Record.AddSourceLocation(Loc: E->getEndLoc());
2487}
2488
2489void ASTStmtWriter::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
2490 VisitStmt(S: D);
2491 Record.writeUInt32(Value: D->getLoopsNumber());
2492 VisitOMPExecutableDirective(E: D);
2493}
2494
2495void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
2496 VisitOMPLoopBasedDirective(D);
2497}
2498
2499void ASTStmtWriter::VisitOMPMetaDirective(OMPMetaDirective *D) {
2500 VisitStmt(S: D);
2501 Record.push_back(N: D->getNumClauses());
2502 VisitOMPExecutableDirective(E: D);
2503 Code = serialization::STMT_OMP_META_DIRECTIVE;
2504}
2505
2506void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
2507 VisitStmt(S: D);
2508 VisitOMPExecutableDirective(E: D);
2509 Record.writeBool(Value: D->hasCancel());
2510 Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
2511}
2512
2513void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
2514 VisitOMPLoopDirective(D);
2515 Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
2516}
2517
2518void ASTStmtWriter::VisitOMPCanonicalLoopNestTransformationDirective(
2519 OMPCanonicalLoopNestTransformationDirective *D) {
2520 VisitOMPLoopBasedDirective(D);
2521 Record.writeUInt32(Value: D->getNumGeneratedTopLevelLoops());
2522}
2523
2524void ASTStmtWriter::VisitOMPTileDirective(OMPTileDirective *D) {
2525 VisitOMPCanonicalLoopNestTransformationDirective(D);
2526 Code = serialization::STMT_OMP_TILE_DIRECTIVE;
2527}
2528
2529void ASTStmtWriter::VisitOMPStripeDirective(OMPStripeDirective *D) {
2530 VisitOMPCanonicalLoopNestTransformationDirective(D);
2531 Code = serialization::STMP_OMP_STRIPE_DIRECTIVE;
2532}
2533
2534void ASTStmtWriter::VisitOMPUnrollDirective(OMPUnrollDirective *D) {
2535 VisitOMPCanonicalLoopNestTransformationDirective(D);
2536 Code = serialization::STMT_OMP_UNROLL_DIRECTIVE;
2537}
2538
2539void ASTStmtWriter::VisitOMPReverseDirective(OMPReverseDirective *D) {
2540 VisitOMPCanonicalLoopNestTransformationDirective(D);
2541 Code = serialization::STMT_OMP_REVERSE_DIRECTIVE;
2542}
2543
2544void ASTStmtWriter::VisitOMPInterchangeDirective(OMPInterchangeDirective *D) {
2545 VisitOMPCanonicalLoopNestTransformationDirective(D);
2546 Code = serialization::STMT_OMP_INTERCHANGE_DIRECTIVE;
2547}
2548
2549void ASTStmtWriter::VisitOMPCanonicalLoopSequenceTransformationDirective(
2550 OMPCanonicalLoopSequenceTransformationDirective *D) {
2551 VisitStmt(S: D);
2552 VisitOMPExecutableDirective(E: D);
2553 Record.writeUInt32(Value: D->getNumGeneratedTopLevelLoops());
2554}
2555
2556void ASTStmtWriter::VisitOMPFuseDirective(OMPFuseDirective *D) {
2557 VisitOMPCanonicalLoopSequenceTransformationDirective(D);
2558 Code = serialization::STMT_OMP_FUSE_DIRECTIVE;
2559}
2560
2561void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
2562 VisitOMPLoopDirective(D);
2563 Record.writeBool(Value: D->hasCancel());
2564 Code = serialization::STMT_OMP_FOR_DIRECTIVE;
2565}
2566
2567void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2568 VisitOMPLoopDirective(D);
2569 Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE;
2570}
2571
2572void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2573 VisitStmt(S: D);
2574 VisitOMPExecutableDirective(E: D);
2575 Record.writeBool(Value: D->hasCancel());
2576 Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
2577}
2578
2579void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
2580 VisitStmt(S: D);
2581 VisitOMPExecutableDirective(E: D);
2582 Record.writeBool(Value: D->hasCancel());
2583 Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
2584}
2585
2586void ASTStmtWriter::VisitOMPScopeDirective(OMPScopeDirective *D) {
2587 VisitStmt(S: D);
2588 VisitOMPExecutableDirective(E: D);
2589 Code = serialization::STMT_OMP_SCOPE_DIRECTIVE;
2590}
2591
2592void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
2593 VisitStmt(S: D);
2594 VisitOMPExecutableDirective(E: D);
2595 Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
2596}
2597
2598void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
2599 VisitStmt(S: D);
2600 VisitOMPExecutableDirective(E: D);
2601 Code = serialization::STMT_OMP_MASTER_DIRECTIVE;
2602}
2603
2604void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2605 VisitStmt(S: D);
2606 VisitOMPExecutableDirective(E: D);
2607 Record.AddDeclarationNameInfo(NameInfo: D->getDirectiveName());
2608 Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
2609}
2610
2611void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2612 VisitOMPLoopDirective(D);
2613 Record.writeBool(Value: D->hasCancel());
2614 Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
2615}
2616
2617void ASTStmtWriter::VisitOMPParallelForSimdDirective(
2618 OMPParallelForSimdDirective *D) {
2619 VisitOMPLoopDirective(D);
2620 Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
2621}
2622
2623void ASTStmtWriter::VisitOMPParallelMasterDirective(
2624 OMPParallelMasterDirective *D) {
2625 VisitStmt(S: D);
2626 VisitOMPExecutableDirective(E: D);
2627 Code = serialization::STMT_OMP_PARALLEL_MASTER_DIRECTIVE;
2628}
2629
2630void ASTStmtWriter::VisitOMPParallelMaskedDirective(
2631 OMPParallelMaskedDirective *D) {
2632 VisitStmt(S: D);
2633 VisitOMPExecutableDirective(E: D);
2634 Code = serialization::STMT_OMP_PARALLEL_MASKED_DIRECTIVE;
2635}
2636
2637void ASTStmtWriter::VisitOMPParallelSectionsDirective(
2638 OMPParallelSectionsDirective *D) {
2639 VisitStmt(S: D);
2640 VisitOMPExecutableDirective(E: D);
2641 Record.writeBool(Value: D->hasCancel());
2642 Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
2643}
2644
2645void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
2646 VisitStmt(S: D);
2647 VisitOMPExecutableDirective(E: D);
2648 Record.writeBool(Value: D->hasCancel());
2649 Code = serialization::STMT_OMP_TASK_DIRECTIVE;
2650}
2651
2652void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2653 VisitStmt(S: D);
2654 VisitOMPExecutableDirective(E: D);
2655 Record.writeBool(Value: D->isXLHSInRHSPart());
2656 Record.writeBool(Value: D->isPostfixUpdate());
2657 Record.writeBool(Value: D->isFailOnly());
2658 Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
2659}
2660
2661void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
2662 VisitStmt(S: D);
2663 VisitOMPExecutableDirective(E: D);
2664 Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
2665}
2666
2667void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2668 VisitStmt(S: D);
2669 VisitOMPExecutableDirective(E: D);
2670 Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE;
2671}
2672
2673void ASTStmtWriter::VisitOMPTargetEnterDataDirective(
2674 OMPTargetEnterDataDirective *D) {
2675 VisitStmt(S: D);
2676 VisitOMPExecutableDirective(E: D);
2677 Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE;
2678}
2679
2680void ASTStmtWriter::VisitOMPTargetExitDataDirective(
2681 OMPTargetExitDataDirective *D) {
2682 VisitStmt(S: D);
2683 VisitOMPExecutableDirective(E: D);
2684 Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE;
2685}
2686
2687void ASTStmtWriter::VisitOMPTargetParallelDirective(
2688 OMPTargetParallelDirective *D) {
2689 VisitStmt(S: D);
2690 VisitOMPExecutableDirective(E: D);
2691 Record.writeBool(Value: D->hasCancel());
2692 Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE;
2693}
2694
2695void ASTStmtWriter::VisitOMPTargetParallelForDirective(
2696 OMPTargetParallelForDirective *D) {
2697 VisitOMPLoopDirective(D);
2698 Record.writeBool(Value: D->hasCancel());
2699 Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE;
2700}
2701
2702void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2703 VisitStmt(S: D);
2704 VisitOMPExecutableDirective(E: D);
2705 Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
2706}
2707
2708void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2709 VisitStmt(S: D);
2710 VisitOMPExecutableDirective(E: D);
2711 Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
2712}
2713
2714void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2715 VisitStmt(S: D);
2716 Record.push_back(N: D->getNumClauses());
2717 VisitOMPExecutableDirective(E: D);
2718 Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
2719}
2720
2721void ASTStmtWriter::VisitOMPAssumeDirective(OMPAssumeDirective *D) {
2722 VisitStmt(S: D);
2723 VisitOMPExecutableDirective(E: D);
2724 Code = serialization::STMT_OMP_ASSUME_DIRECTIVE;
2725}
2726
2727void ASTStmtWriter::VisitOMPErrorDirective(OMPErrorDirective *D) {
2728 VisitStmt(S: D);
2729 Record.push_back(N: D->getNumClauses());
2730 VisitOMPExecutableDirective(E: D);
2731 Code = serialization::STMT_OMP_ERROR_DIRECTIVE;
2732}
2733
2734void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2735 VisitStmt(S: D);
2736 VisitOMPExecutableDirective(E: D);
2737 Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE;
2738}
2739
2740void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
2741 VisitStmt(S: D);
2742 VisitOMPExecutableDirective(E: D);
2743 Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
2744}
2745
2746void ASTStmtWriter::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2747 VisitStmt(S: D);
2748 VisitOMPExecutableDirective(E: D);
2749 Code = serialization::STMT_OMP_DEPOBJ_DIRECTIVE;
2750}
2751
2752void ASTStmtWriter::VisitOMPScanDirective(OMPScanDirective *D) {
2753 VisitStmt(S: D);
2754 VisitOMPExecutableDirective(E: D);
2755 Code = serialization::STMT_OMP_SCAN_DIRECTIVE;
2756}
2757
2758void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2759 VisitStmt(S: D);
2760 VisitOMPExecutableDirective(E: D);
2761 Code = serialization::STMT_OMP_ORDERED_DIRECTIVE;
2762}
2763
2764void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2765 VisitStmt(S: D);
2766 VisitOMPExecutableDirective(E: D);
2767 Code = serialization::STMT_OMP_TEAMS_DIRECTIVE;
2768}
2769
2770void ASTStmtWriter::VisitOMPCancellationPointDirective(
2771 OMPCancellationPointDirective *D) {
2772 VisitStmt(S: D);
2773 VisitOMPExecutableDirective(E: D);
2774 Record.writeEnum(value: D->getCancelRegion());
2775 Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
2776}
2777
2778void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
2779 VisitStmt(S: D);
2780 VisitOMPExecutableDirective(E: D);
2781 Record.writeEnum(value: D->getCancelRegion());
2782 Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
2783}
2784
2785void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2786 VisitOMPLoopDirective(D);
2787 Record.writeBool(Value: D->hasCancel());
2788 Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE;
2789}
2790
2791void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2792 VisitOMPLoopDirective(D);
2793 Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE;
2794}
2795
2796void ASTStmtWriter::VisitOMPMasterTaskLoopDirective(
2797 OMPMasterTaskLoopDirective *D) {
2798 VisitOMPLoopDirective(D);
2799 Record.writeBool(Value: D->hasCancel());
2800 Code = serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE;
2801}
2802
2803void ASTStmtWriter::VisitOMPMaskedTaskLoopDirective(
2804 OMPMaskedTaskLoopDirective *D) {
2805 VisitOMPLoopDirective(D);
2806 Record.writeBool(Value: D->hasCancel());
2807 Code = serialization::STMT_OMP_MASKED_TASKLOOP_DIRECTIVE;
2808}
2809
2810void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(
2811 OMPMasterTaskLoopSimdDirective *D) {
2812 VisitOMPLoopDirective(D);
2813 Code = serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE;
2814}
2815
2816void ASTStmtWriter::VisitOMPMaskedTaskLoopSimdDirective(
2817 OMPMaskedTaskLoopSimdDirective *D) {
2818 VisitOMPLoopDirective(D);
2819 Code = serialization::STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE;
2820}
2821
2822void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective(
2823 OMPParallelMasterTaskLoopDirective *D) {
2824 VisitOMPLoopDirective(D);
2825 Record.writeBool(Value: D->hasCancel());
2826 Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE;
2827}
2828
2829void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopDirective(
2830 OMPParallelMaskedTaskLoopDirective *D) {
2831 VisitOMPLoopDirective(D);
2832 Record.writeBool(Value: D->hasCancel());
2833 Code = serialization::STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE;
2834}
2835
2836void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective(
2837 OMPParallelMasterTaskLoopSimdDirective *D) {
2838 VisitOMPLoopDirective(D);
2839 Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE;
2840}
2841
2842void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopSimdDirective(
2843 OMPParallelMaskedTaskLoopSimdDirective *D) {
2844 VisitOMPLoopDirective(D);
2845 Code = serialization::STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE;
2846}
2847
2848void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2849 VisitOMPLoopDirective(D);
2850 Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE;
2851}
2852
2853void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2854 VisitStmt(S: D);
2855 VisitOMPExecutableDirective(E: D);
2856 Code = serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE;
2857}
2858
2859void ASTStmtWriter::VisitOMPDistributeParallelForDirective(
2860 OMPDistributeParallelForDirective *D) {
2861 VisitOMPLoopDirective(D);
2862 Record.writeBool(Value: D->hasCancel());
2863 Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2864}
2865
2866void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective(
2867 OMPDistributeParallelForSimdDirective *D) {
2868 VisitOMPLoopDirective(D);
2869 Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2870}
2871
2872void ASTStmtWriter::VisitOMPDistributeSimdDirective(
2873 OMPDistributeSimdDirective *D) {
2874 VisitOMPLoopDirective(D);
2875 Code = serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE;
2876}
2877
2878void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective(
2879 OMPTargetParallelForSimdDirective *D) {
2880 VisitOMPLoopDirective(D);
2881 Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE;
2882}
2883
2884void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2885 VisitOMPLoopDirective(D);
2886 Code = serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE;
2887}
2888
2889void ASTStmtWriter::VisitOMPTeamsDistributeDirective(
2890 OMPTeamsDistributeDirective *D) {
2891 VisitOMPLoopDirective(D);
2892 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE;
2893}
2894
2895void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective(
2896 OMPTeamsDistributeSimdDirective *D) {
2897 VisitOMPLoopDirective(D);
2898 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
2899}
2900
2901void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective(
2902 OMPTeamsDistributeParallelForSimdDirective *D) {
2903 VisitOMPLoopDirective(D);
2904 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2905}
2906
2907void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective(
2908 OMPTeamsDistributeParallelForDirective *D) {
2909 VisitOMPLoopDirective(D);
2910 Record.writeBool(Value: D->hasCancel());
2911 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2912}
2913
2914void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2915 VisitStmt(S: D);
2916 VisitOMPExecutableDirective(E: D);
2917 Code = serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE;
2918}
2919
2920void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective(
2921 OMPTargetTeamsDistributeDirective *D) {
2922 VisitOMPLoopDirective(D);
2923 Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE;
2924}
2925
2926void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective(
2927 OMPTargetTeamsDistributeParallelForDirective *D) {
2928 VisitOMPLoopDirective(D);
2929 Record.writeBool(Value: D->hasCancel());
2930 Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2931}
2932
2933void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2934 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2935 VisitOMPLoopDirective(D);
2936 Code = serialization::
2937 STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2938}
2939
2940void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective(
2941 OMPTargetTeamsDistributeSimdDirective *D) {
2942 VisitOMPLoopDirective(D);
2943 Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
2944}
2945
2946void ASTStmtWriter::VisitOMPInteropDirective(OMPInteropDirective *D) {
2947 VisitStmt(S: D);
2948 VisitOMPExecutableDirective(E: D);
2949 Code = serialization::STMT_OMP_INTEROP_DIRECTIVE;
2950}
2951
2952void ASTStmtWriter::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
2953 VisitStmt(S: D);
2954 VisitOMPExecutableDirective(E: D);
2955 Record.AddSourceLocation(Loc: D->getTargetCallLoc());
2956 Code = serialization::STMT_OMP_DISPATCH_DIRECTIVE;
2957}
2958
2959void ASTStmtWriter::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
2960 VisitStmt(S: D);
2961 VisitOMPExecutableDirective(E: D);
2962 Code = serialization::STMT_OMP_MASKED_DIRECTIVE;
2963}
2964
2965void ASTStmtWriter::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) {
2966 VisitOMPLoopDirective(D);
2967 Code = serialization::STMT_OMP_GENERIC_LOOP_DIRECTIVE;
2968}
2969
2970void ASTStmtWriter::VisitOMPTeamsGenericLoopDirective(
2971 OMPTeamsGenericLoopDirective *D) {
2972 VisitOMPLoopDirective(D);
2973 Code = serialization::STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE;
2974}
2975
2976void ASTStmtWriter::VisitOMPTargetTeamsGenericLoopDirective(
2977 OMPTargetTeamsGenericLoopDirective *D) {
2978 VisitOMPLoopDirective(D);
2979 Record.writeBool(Value: D->canBeParallelFor());
2980 Code = serialization::STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE;
2981}
2982
2983void ASTStmtWriter::VisitOMPParallelGenericLoopDirective(
2984 OMPParallelGenericLoopDirective *D) {
2985 VisitOMPLoopDirective(D);
2986 Code = serialization::STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE;
2987}
2988
2989void ASTStmtWriter::VisitOMPTargetParallelGenericLoopDirective(
2990 OMPTargetParallelGenericLoopDirective *D) {
2991 VisitOMPLoopDirective(D);
2992 Code = serialization::STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE;
2993}
2994
2995//===----------------------------------------------------------------------===//
2996// OpenACC Constructs/Directives.
2997//===----------------------------------------------------------------------===//
2998void ASTStmtWriter::VisitOpenACCConstructStmt(OpenACCConstructStmt *S) {
2999 Record.push_back(N: S->clauses().size());
3000 Record.writeEnum(value: S->Kind);
3001 Record.AddSourceRange(Range: S->Range);
3002 Record.AddSourceLocation(Loc: S->DirectiveLoc);
3003 Record.writeOpenACCClauseList(Clauses: S->clauses());
3004}
3005
3006void ASTStmtWriter::VisitOpenACCAssociatedStmtConstruct(
3007 OpenACCAssociatedStmtConstruct *S) {
3008 VisitOpenACCConstructStmt(S);
3009 Record.AddStmt(S: S->getAssociatedStmt());
3010}
3011
3012void ASTStmtWriter::VisitOpenACCComputeConstruct(OpenACCComputeConstruct *S) {
3013 VisitStmt(S);
3014 VisitOpenACCAssociatedStmtConstruct(S);
3015 Code = serialization::STMT_OPENACC_COMPUTE_CONSTRUCT;
3016}
3017
3018void ASTStmtWriter::VisitOpenACCLoopConstruct(OpenACCLoopConstruct *S) {
3019 VisitStmt(S);
3020 VisitOpenACCAssociatedStmtConstruct(S);
3021 Record.writeEnum(value: S->getParentComputeConstructKind());
3022 Code = serialization::STMT_OPENACC_LOOP_CONSTRUCT;
3023}
3024
3025void ASTStmtWriter::VisitOpenACCCombinedConstruct(OpenACCCombinedConstruct *S) {
3026 VisitStmt(S);
3027 VisitOpenACCAssociatedStmtConstruct(S);
3028 Code = serialization::STMT_OPENACC_COMBINED_CONSTRUCT;
3029}
3030
3031void ASTStmtWriter::VisitOpenACCDataConstruct(OpenACCDataConstruct *S) {
3032 VisitStmt(S);
3033 VisitOpenACCAssociatedStmtConstruct(S);
3034 Code = serialization::STMT_OPENACC_DATA_CONSTRUCT;
3035}
3036
3037void ASTStmtWriter::VisitOpenACCEnterDataConstruct(
3038 OpenACCEnterDataConstruct *S) {
3039 VisitStmt(S);
3040 VisitOpenACCConstructStmt(S);
3041 Code = serialization::STMT_OPENACC_ENTER_DATA_CONSTRUCT;
3042}
3043
3044void ASTStmtWriter::VisitOpenACCExitDataConstruct(OpenACCExitDataConstruct *S) {
3045 VisitStmt(S);
3046 VisitOpenACCConstructStmt(S);
3047 Code = serialization::STMT_OPENACC_EXIT_DATA_CONSTRUCT;
3048}
3049
3050void ASTStmtWriter::VisitOpenACCInitConstruct(OpenACCInitConstruct *S) {
3051 VisitStmt(S);
3052 VisitOpenACCConstructStmt(S);
3053 Code = serialization::STMT_OPENACC_INIT_CONSTRUCT;
3054}
3055
3056void ASTStmtWriter::VisitOpenACCShutdownConstruct(OpenACCShutdownConstruct *S) {
3057 VisitStmt(S);
3058 VisitOpenACCConstructStmt(S);
3059 Code = serialization::STMT_OPENACC_SHUTDOWN_CONSTRUCT;
3060}
3061
3062void ASTStmtWriter::VisitOpenACCSetConstruct(OpenACCSetConstruct *S) {
3063 VisitStmt(S);
3064 VisitOpenACCConstructStmt(S);
3065 Code = serialization::STMT_OPENACC_SET_CONSTRUCT;
3066}
3067
3068void ASTStmtWriter::VisitOpenACCUpdateConstruct(OpenACCUpdateConstruct *S) {
3069 VisitStmt(S);
3070 VisitOpenACCConstructStmt(S);
3071 Code = serialization::STMT_OPENACC_UPDATE_CONSTRUCT;
3072}
3073
3074void ASTStmtWriter::VisitOpenACCHostDataConstruct(OpenACCHostDataConstruct *S) {
3075 VisitStmt(S);
3076 VisitOpenACCAssociatedStmtConstruct(S);
3077 Code = serialization::STMT_OPENACC_HOST_DATA_CONSTRUCT;
3078}
3079
3080void ASTStmtWriter::VisitOpenACCWaitConstruct(OpenACCWaitConstruct *S) {
3081 VisitStmt(S);
3082 Record.push_back(N: S->getExprs().size());
3083 VisitOpenACCConstructStmt(S);
3084 Record.AddSourceLocation(Loc: S->LParenLoc);
3085 Record.AddSourceLocation(Loc: S->RParenLoc);
3086 Record.AddSourceLocation(Loc: S->QueuesLoc);
3087
3088 for(Expr *E : S->getExprs())
3089 Record.AddStmt(S: E);
3090
3091 Code = serialization::STMT_OPENACC_WAIT_CONSTRUCT;
3092}
3093
3094void ASTStmtWriter::VisitOpenACCAtomicConstruct(OpenACCAtomicConstruct *S) {
3095 VisitStmt(S);
3096 VisitOpenACCConstructStmt(S);
3097 Record.writeEnum(value: S->getAtomicKind());
3098 Record.AddStmt(S: S->getAssociatedStmt());
3099
3100 Code = serialization::STMT_OPENACC_ATOMIC_CONSTRUCT;
3101}
3102
3103void ASTStmtWriter::VisitOpenACCCacheConstruct(OpenACCCacheConstruct *S) {
3104 VisitStmt(S);
3105 Record.push_back(N: S->getVarList().size());
3106 VisitOpenACCConstructStmt(S);
3107 Record.AddSourceRange(Range: S->ParensLoc);
3108 Record.AddSourceLocation(Loc: S->ReadOnlyLoc);
3109
3110 for (Expr *E : S->getVarList())
3111 Record.AddStmt(S: E);
3112 Code = serialization::STMT_OPENACC_CACHE_CONSTRUCT;
3113}
3114
3115//===----------------------------------------------------------------------===//
3116// HLSL Constructs/Directives.
3117//===----------------------------------------------------------------------===//
3118
3119void ASTStmtWriter::VisitHLSLOutArgExpr(HLSLOutArgExpr *S) {
3120 VisitExpr(E: S);
3121 Record.AddStmt(S: S->getOpaqueArgLValue());
3122 Record.AddStmt(S: S->getCastedTemporary());
3123 Record.AddStmt(S: S->getWritebackCast());
3124 Record.writeBool(Value: S->isInOut());
3125 Code = serialization::EXPR_HLSL_OUT_ARG;
3126}
3127
3128//===----------------------------------------------------------------------===//
3129// ASTWriter Implementation
3130//===----------------------------------------------------------------------===//
3131
3132unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
3133 assert(!SwitchCaseIDs.contains(S) && "SwitchCase recorded twice");
3134 unsigned NextID = SwitchCaseIDs.size();
3135 SwitchCaseIDs[S] = NextID;
3136 return NextID;
3137}
3138
3139unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
3140 assert(SwitchCaseIDs.contains(S) && "SwitchCase hasn't been seen yet");
3141 return SwitchCaseIDs[S];
3142}
3143
3144void ASTWriter::ClearSwitchCaseIDs() {
3145 SwitchCaseIDs.clear();
3146}
3147
3148/// Write the given substatement or subexpression to the
3149/// bitstream.
3150void ASTWriter::WriteSubStmt(ASTContext &Context, Stmt *S) {
3151 RecordData Record;
3152 ASTStmtWriter Writer(Context, *this, Record);
3153 ++NumStatements;
3154
3155 if (!S) {
3156 Stream.EmitRecord(Code: serialization::STMT_NULL_PTR, Vals: Record);
3157 return;
3158 }
3159
3160 llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(Val: S);
3161 if (I != SubStmtEntries.end()) {
3162 Record.push_back(Elt: I->second);
3163 Stream.EmitRecord(Code: serialization::STMT_REF_PTR, Vals: Record);
3164 return;
3165 }
3166
3167#ifndef NDEBUG
3168 assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
3169
3170 struct ParentStmtInserterRAII {
3171 Stmt *S;
3172 llvm::DenseSet<Stmt *> &ParentStmts;
3173
3174 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
3175 : S(S), ParentStmts(ParentStmts) {
3176 ParentStmts.insert(S);
3177 }
3178 ~ParentStmtInserterRAII() {
3179 ParentStmts.erase(S);
3180 }
3181 };
3182
3183 ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
3184#endif
3185
3186 Writer.Visit(S);
3187
3188 uint64_t Offset = Writer.Emit();
3189 SubStmtEntries[S] = Offset;
3190}
3191
3192/// Flush all of the statements that have been added to the
3193/// queue via AddStmt().
3194void ASTRecordWriter::FlushStmts() {
3195 // We expect to be the only consumer of the two temporary statement maps,
3196 // assert that they are empty.
3197 assert(Writer->SubStmtEntries.empty() && "unexpected entries in sub-stmt map");
3198 assert(Writer->ParentStmts.empty() && "unexpected entries in parent stmt map");
3199
3200 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
3201 Writer->WriteSubStmt(Context&: getASTContext(), S: StmtsToEmit[I]);
3202
3203 assert(N == StmtsToEmit.size() && "record modified while being written!");
3204
3205 // Note that we are at the end of a full expression. Any
3206 // expression records that follow this one are part of a different
3207 // expression.
3208 Writer->Stream.EmitRecord(Code: serialization::STMT_STOP, Vals: ArrayRef<uint32_t>());
3209
3210 Writer->SubStmtEntries.clear();
3211 Writer->ParentStmts.clear();
3212 }
3213
3214 StmtsToEmit.clear();
3215}
3216
3217void ASTRecordWriter::FlushSubStmts() {
3218 // For a nested statement, write out the substatements in reverse order (so
3219 // that a simple stack machine can be used when loading), and don't emit a
3220 // STMT_STOP after each one.
3221 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
3222 Writer->WriteSubStmt(Context&: getASTContext(), S: StmtsToEmit[N - I - 1]);
3223 assert(N == StmtsToEmit.size() && "record modified while being written!");
3224 }
3225
3226 StmtsToEmit.clear();
3227}
3228