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