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