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