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