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