head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.13 netbsd-11-0-RC3:1.1.1.13 netbsd-11-0-RC2:1.1.1.13 netbsd-11-0-RC1:1.1.1.13 perseant-exfatfs-base-20250801:1.1.1.13 netbsd-11:1.1.1.13.0.10 netbsd-11-base:1.1.1.13 netbsd-10-1-RELEASE:1.1.1.13 perseant-exfatfs-base-20240630:1.1.1.13 perseant-exfatfs:1.1.1.13.0.8 perseant-exfatfs-base:1.1.1.13 netbsd-8-3-RELEASE:1.1.1.9 netbsd-9-4-RELEASE:1.1.1.12 netbsd-10-0-RELEASE:1.1.1.13 netbsd-10-0-RC6:1.1.1.13 netbsd-10-0-RC5:1.1.1.13 netbsd-10-0-RC4:1.1.1.13 netbsd-10-0-RC3:1.1.1.13 netbsd-10-0-RC2:1.1.1.13 netbsd-10-0-RC1:1.1.1.13 netbsd-10:1.1.1.13.0.6 netbsd-10-base:1.1.1.13 netbsd-9-3-RELEASE:1.1.1.12 cjep_sun2x:1.1.1.13.0.4 cjep_sun2x-base:1.1.1.13 cjep_staticlib_x-base1:1.1.1.13 netbsd-9-2-RELEASE:1.1.1.12 cjep_staticlib_x:1.1.1.13.0.2 cjep_staticlib_x-base:1.1.1.13 netbsd-9-1-RELEASE:1.1.1.12 phil-wifi-20200421:1.1.1.13 phil-wifi-20200411:1.1.1.13 phil-wifi-20200406:1.1.1.13 netbsd-8-2-RELEASE:1.1.1.9 netbsd-9-0-RELEASE:1.1.1.12 netbsd-9-0-RC2:1.1.1.12 netbsd-9-0-RC1:1.1.1.12 netbsd-9:1.1.1.12.0.2 netbsd-9-base:1.1.1.12 phil-wifi-20190609:1.1.1.12 netbsd-8-1-RELEASE:1.1.1.9 netbsd-8-1-RC1:1.1.1.9 pgoyette-compat-merge-20190127:1.1.1.11.2.1 pgoyette-compat-20190127:1.1.1.12 pgoyette-compat-20190118:1.1.1.12 pgoyette-compat-1226:1.1.1.12 pgoyette-compat-1126:1.1.1.12 pgoyette-compat-1020:1.1.1.12 pgoyette-compat-0930:1.1.1.12 pgoyette-compat-0906:1.1.1.12 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.12 clang-337282:1.1.1.12 netbsd-8-0-RELEASE:1.1.1.9 phil-wifi:1.1.1.11.0.4 phil-wifi-base:1.1.1.11 pgoyette-compat-0625:1.1.1.11 netbsd-8-0-RC2:1.1.1.9 pgoyette-compat-0521:1.1.1.11 pgoyette-compat-0502:1.1.1.11 pgoyette-compat-0422:1.1.1.11 netbsd-8-0-RC1:1.1.1.9 pgoyette-compat-0415:1.1.1.11 pgoyette-compat-0407:1.1.1.11 pgoyette-compat-0330:1.1.1.11 pgoyette-compat-0322:1.1.1.11 pgoyette-compat-0315:1.1.1.11 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.11.0.2 pgoyette-compat-base:1.1.1.11 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.11 matt-nb8-mediatek:1.1.1.9.0.8 matt-nb8-mediatek-base:1.1.1.9 clang-309604:1.1.1.10 perseant-stdc-iso10646:1.1.1.9.0.6 perseant-stdc-iso10646-base:1.1.1.9 netbsd-8:1.1.1.9.0.4 netbsd-8-base:1.1.1.9 prg-localcount2-base3:1.1.1.9 prg-localcount2-base2:1.1.1.9 prg-localcount2-base1:1.1.1.9 prg-localcount2:1.1.1.9.0.2 prg-localcount2-base:1.1.1.9 pgoyette-localcount-20170426:1.1.1.9 bouyer-socketcan-base1:1.1.1.9 pgoyette-localcount-20170320:1.1.1.9 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.9 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.2 clang-199312:1.1.1.2 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.24; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.03.04.19.53.36; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid 29z1hJonZISIXprx; 1.1.1.4 date 2014.05.30.18.14.44; author joerg; state Exp; branches; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2014.08.10.17.08.26; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid N85tXAN6Ex9VZPLx; 1.1.1.6 date 2015.01.29.19.57.32; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.11.51; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.35.22; author joerg; state Exp; branches 1.1.1.8.2.1; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2017.02.09.17.38.27; author joerg; state Exp; branches; next 1.1.1.10; commitid UxB8JMFWM7xyMiFz; 1.1.1.10 date 2017.08.01.19.35.34; author joerg; state Exp; branches; next 1.1.1.11; commitid pMuDy65V0VicSx1A; 1.1.1.11 date 2017.12.17.20.59.10; author joerg; state Exp; branches 1.1.1.11.2.1 1.1.1.11.4.1; next 1.1.1.12; commitid T7p9sjiUJyY1UhjA; 1.1.1.12 date 2018.07.17.18.31.26; author joerg; state Exp; branches; next 1.1.1.13; commitid wDzL46ALjrCZgwKA; 1.1.1.13 date 2019.11.13.22.19.28; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.10; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.03.04.19.53.36; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.18.30; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.30; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.08.10.17.08.26; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.31; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.52.41; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.8.2.1 date 2017.04.21.16.51.40; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.11.2.1 date 2018.07.28.04.33.23; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.11.4.1 date 2019.06.10.21.45.28; author christos; state Exp; branches; next 1.1.1.11.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.11.4.2 date 2020.04.13.07.46.38; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief Implements serialization for Statements and Expressions. /// //===----------------------------------------------------------------------===// #include "clang/Serialization/ASTWriter.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/StmtVisitor.h" #include "clang/Lex/Token.h" #include "llvm/Bitcode/BitstreamWriter.h" using namespace clang; //===----------------------------------------------------------------------===// // Statement/expression serialization //===----------------------------------------------------------------------===// namespace clang { class ASTStmtWriter : public StmtVisitor { friend class OMPClauseWriter; ASTWriter &Writer; ASTWriter::RecordData &Record; public: serialization::StmtCode Code; unsigned AbbrevToUse; ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record) : Writer(Writer), Record(Record) { } void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &Args); void VisitStmt(Stmt *S); #define STMT(Type, Base) \ void Visit##Type(Type *); #include "clang/AST/StmtNodes.inc" }; } void ASTStmtWriter:: AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &Args) { Writer.AddSourceLocation(Args.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(Args.LAngleLoc, Record); Writer.AddSourceLocation(Args.RAngleLoc, Record); for (unsigned i=0; i != Args.NumTemplateArgs; ++i) Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record); } void ASTStmtWriter::VisitStmt(Stmt *S) { } void ASTStmtWriter::VisitNullStmt(NullStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getSemiLoc(), Record); Record.push_back(S->HasLeadingEmptyMacro); Code = serialization::STMT_NULL; } void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) { VisitStmt(S); Record.push_back(S->size()); for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end(); CS != CSEnd; ++CS) Writer.AddStmt(*CS); Writer.AddSourceLocation(S->getLBracLoc(), Record); Writer.AddSourceLocation(S->getRBracLoc(), Record); Code = serialization::STMT_COMPOUND; } void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) { VisitStmt(S); Record.push_back(Writer.getSwitchCaseID(S)); Writer.AddSourceLocation(S->getKeywordLoc(), Record); Writer.AddSourceLocation(S->getColonLoc(), Record); } void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) { VisitSwitchCase(S); Writer.AddStmt(S->getLHS()); Writer.AddStmt(S->getRHS()); Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getEllipsisLoc(), Record); Code = serialization::STMT_CASE; } void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) { VisitSwitchCase(S); Writer.AddStmt(S->getSubStmt()); Code = serialization::STMT_DEFAULT; } void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getDecl(), Record); Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getIdentLoc(), Record); Code = serialization::STMT_LABEL; } void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) { VisitStmt(S); Record.push_back(S->getAttrs().size()); Writer.WriteAttributes(S->getAttrs(), Record); Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getAttrLoc(), Record); Code = serialization::STMT_ATTRIBUTED; } void ASTStmtWriter::VisitIfStmt(IfStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getThen()); Writer.AddStmt(S->getElse()); Writer.AddSourceLocation(S->getIfLoc(), Record); Writer.AddSourceLocation(S->getElseLoc(), Record); Code = serialization::STMT_IF; } void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getSwitchLoc(), Record); Record.push_back(S->isAllEnumCasesCovered()); for (SwitchCase *SC = S->getSwitchCaseList(); SC; SC = SC->getNextSwitchCase()) Record.push_back(Writer.RecordSwitchCaseID(SC)); Code = serialization::STMT_SWITCH; } void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getWhileLoc(), Record); Code = serialization::STMT_WHILE; } void ASTStmtWriter::VisitDoStmt(DoStmt *S) { VisitStmt(S); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getDoLoc(), Record); Writer.AddSourceLocation(S->getWhileLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_DO; } void ASTStmtWriter::VisitForStmt(ForStmt *S) { VisitStmt(S); Writer.AddStmt(S->getInit()); Writer.AddStmt(S->getCond()); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getInc()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getLParenLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_FOR; } void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getLabel(), Record); Writer.AddSourceLocation(S->getGotoLoc(), Record); Writer.AddSourceLocation(S->getLabelLoc(), Record); Code = serialization::STMT_GOTO; } void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getGotoLoc(), Record); Writer.AddSourceLocation(S->getStarLoc(), Record); Writer.AddStmt(S->getTarget()); Code = serialization::STMT_INDIRECT_GOTO; } void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getContinueLoc(), Record); Code = serialization::STMT_CONTINUE; } void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getBreakLoc(), Record); Code = serialization::STMT_BREAK; } void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) { VisitStmt(S); Writer.AddStmt(S->getRetValue()); Writer.AddSourceLocation(S->getReturnLoc(), Record); Writer.AddDeclRef(S->getNRVOCandidate(), Record); Code = serialization::STMT_RETURN; } void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getStartLoc(), Record); Writer.AddSourceLocation(S->getEndLoc(), Record); DeclGroupRef DG = S->getDeclGroup(); for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D) Writer.AddDeclRef(*D, Record); Code = serialization::STMT_DECL; } void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) { VisitStmt(S); Record.push_back(S->getNumOutputs()); Record.push_back(S->getNumInputs()); Record.push_back(S->getNumClobbers()); Writer.AddSourceLocation(S->getAsmLoc(), Record); Record.push_back(S->isVolatile()); Record.push_back(S->isSimple()); } void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) { VisitAsmStmt(S); Writer.AddSourceLocation(S->getRParenLoc(), Record); Writer.AddStmt(S->getAsmString()); // Outputs for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record); Writer.AddStmt(S->getOutputConstraintLiteral(I)); Writer.AddStmt(S->getOutputExpr(I)); } // Inputs for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { Writer.AddIdentifierRef(S->getInputIdentifier(I), Record); Writer.AddStmt(S->getInputConstraintLiteral(I)); Writer.AddStmt(S->getInputExpr(I)); } // Clobbers for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) Writer.AddStmt(S->getClobberStringLiteral(I)); Code = serialization::STMT_GCCASM; } void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) { VisitAsmStmt(S); Writer.AddSourceLocation(S->getLBraceLoc(), Record); Writer.AddSourceLocation(S->getEndLoc(), Record); Record.push_back(S->getNumAsmToks()); Writer.AddString(S->getAsmString(), Record); // Tokens for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) { Writer.AddToken(S->getAsmToks()[I], Record); } // Clobbers for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) { Writer.AddString(S->getClobber(I), Record); } // Outputs for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { Writer.AddStmt(S->getOutputExpr(I)); Writer.AddString(S->getOutputConstraint(I), Record); } // Inputs for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { Writer.AddStmt(S->getInputExpr(I)); Writer.AddString(S->getInputConstraint(I), Record); } Code = serialization::STMT_MSASM; } void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) { VisitStmt(S); // NumCaptures Record.push_back(std::distance(S->capture_begin(), S->capture_end())); // CapturedDecl and captured region kind Writer.AddDeclRef(S->getCapturedDecl(), Record); Record.push_back(S->getCapturedRegionKind()); Writer.AddDeclRef(S->getCapturedRecordDecl(), Record); // Capture inits for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(), E = S->capture_init_end(); I != E; ++I) Writer.AddStmt(*I); // Body Writer.AddStmt(S->getCapturedStmt()); // Captures for (CapturedStmt::capture_iterator I = S->capture_begin(), E = S->capture_end(); I != E; ++I) { if (I->capturesThis()) Writer.AddDeclRef(0, Record); else Writer.AddDeclRef(I->getCapturedVar(), Record); Record.push_back(I->getCaptureKind()); Writer.AddSourceLocation(I->getLocation(), Record); } Code = serialization::STMT_CAPTURED; } void ASTStmtWriter::VisitExpr(Expr *E) { VisitStmt(E); Writer.AddTypeRef(E->getType(), Record); Record.push_back(E->isTypeDependent()); Record.push_back(E->isValueDependent()); Record.push_back(E->isInstantiationDependent()); Record.push_back(E->containsUnexpandedParameterPack()); Record.push_back(E->getValueKind()); Record.push_back(E->getObjectKind()); } void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->getIdentType()); // FIXME: stable encoding Code = serialization::EXPR_PREDEFINED; } void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) { VisitExpr(E); Record.push_back(E->hasQualifier()); Record.push_back(E->getDecl() != E->getFoundDecl()); Record.push_back(E->hasTemplateKWAndArgsInfo()); Record.push_back(E->hadMultipleCandidates()); Record.push_back(E->refersToEnclosingLocal()); if (E->hasTemplateKWAndArgsInfo()) { unsigned NumTemplateArgs = E->getNumTemplateArgs(); Record.push_back(NumTemplateArgs); } DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind()); if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) && (E->getDecl() == E->getFoundDecl()) && nk == DeclarationName::Identifier) { AbbrevToUse = Writer.getDeclRefExprAbbrev(); } if (E->hasQualifier()) Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); if (E->getDecl() != E->getFoundDecl()) Writer.AddDeclRef(E->getFoundDecl(), Record); if (E->hasTemplateKWAndArgsInfo()) AddTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo()); Writer.AddDeclRef(E->getDecl(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record); Code = serialization::EXPR_DECL_REF; } void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddAPInt(E->getValue(), Record); if (E->getValue().getBitWidth() == 32) { AbbrevToUse = Writer.getIntegerLiteralAbbrev(); } Code = serialization::EXPR_INTEGER_LITERAL; } void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) { VisitExpr(E); Record.push_back(E->getRawSemantics()); Record.push_back(E->isExact()); Writer.AddAPFloat(E->getValue(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_FLOATING_LITERAL; } void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_IMAGINARY_LITERAL; } void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) { VisitExpr(E); Record.push_back(E->getByteLength()); Record.push_back(E->getNumConcatenated()); Record.push_back(E->getKind()); Record.push_back(E->isPascal()); // FIXME: String data should be stored as a blob at the end of the // StringLiteral. However, we can't do so now because we have no // provision for coping with abbreviations when we're jumping around // the AST file during deserialization. Record.append(E->getBytes().begin(), E->getBytes().end()); for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I) Writer.AddSourceLocation(E->getStrTokenLoc(I), Record); Code = serialization::EXPR_STRING_LITERAL; } void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->getKind()); AbbrevToUse = Writer.getCharacterLiteralAbbrev(); Code = serialization::EXPR_CHARACTER_LITERAL; } void ASTStmtWriter::VisitParenExpr(ParenExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParen(), Record); Writer.AddSourceLocation(E->getRParen(), Record); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_PAREN; } void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) { VisitExpr(E); Record.push_back(E->NumExprs); for (unsigned i=0; i != E->NumExprs; ++i) Writer.AddStmt(E->Exprs[i]); Writer.AddSourceLocation(E->LParenLoc, Record); Writer.AddSourceLocation(E->RParenLoc, Record); Code = serialization::EXPR_PAREN_LIST; } void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = serialization::EXPR_UNARY_OPERATOR; } void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) { VisitExpr(E); Record.push_back(E->getNumComponents()); Record.push_back(E->getNumExpressions()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { const OffsetOfExpr::OffsetOfNode &ON = E->getComponent(I); Record.push_back(ON.getKind()); // FIXME: Stable encoding Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record); Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record); switch (ON.getKind()) { case OffsetOfExpr::OffsetOfNode::Array: Record.push_back(ON.getArrayExprIndex()); break; case OffsetOfExpr::OffsetOfNode::Field: Writer.AddDeclRef(ON.getField(), Record); break; case OffsetOfExpr::OffsetOfNode::Identifier: Writer.AddIdentifierRef(ON.getFieldName(), Record); break; case OffsetOfExpr::OffsetOfNode::Base: Writer.AddCXXBaseSpecifier(*ON.getBase(), Record); break; } } for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) Writer.AddStmt(E->getIndexExpr(I)); Code = serialization::EXPR_OFFSETOF; } void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->getKind()); if (E->isArgumentType()) Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record); else { Record.push_back(0); Writer.AddStmt(E->getArgumentExpr()); } Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_SIZEOF_ALIGN_OF; } void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { VisitExpr(E); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getRBracketLoc(), Record); Code = serialization::EXPR_ARRAY_SUBSCRIPT; } void ASTStmtWriter::VisitCallExpr(CallExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddStmt(E->getCallee()); for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) Writer.AddStmt(*Arg); Code = serialization::EXPR_CALL; } void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) { // Don't call VisitExpr, we'll write everything here. Record.push_back(E->hasQualifier()); if (E->hasQualifier()) Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { Writer.AddSourceLocation(E->getTemplateKeywordLoc(), Record); unsigned NumTemplateArgs = E->getNumTemplateArgs(); Record.push_back(NumTemplateArgs); Writer.AddSourceLocation(E->getLAngleLoc(), Record); Writer.AddSourceLocation(E->getRAngleLoc(), Record); for (unsigned i=0; i != NumTemplateArgs; ++i) Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record); } Record.push_back(E->hadMultipleCandidates()); DeclAccessPair FoundDecl = E->getFoundDecl(); Writer.AddDeclRef(FoundDecl.getDecl(), Record); Record.push_back(FoundDecl.getAccess()); Writer.AddTypeRef(E->getType(), Record); Record.push_back(E->getValueKind()); Record.push_back(E->getObjectKind()); Writer.AddStmt(E->getBase()); Writer.AddDeclRef(E->getMemberDecl(), Record); Writer.AddSourceLocation(E->getMemberLoc(), Record); Record.push_back(E->isArrow()); Writer.AddDeclarationNameLoc(E->MemberDNLoc, E->getMemberDecl()->getDeclName(), Record); Code = serialization::EXPR_MEMBER; } void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Writer.AddSourceLocation(E->getIsaMemberLoc(), Record); Writer.AddSourceLocation(E->getOpLoc(), Record); Record.push_back(E->isArrow()); Code = serialization::EXPR_OBJC_ISA; } void ASTStmtWriter:: VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->shouldCopy()); Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE; } void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getBridgeKeywordLoc(), Record); Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding Code = serialization::EXPR_OBJC_BRIDGED_CAST; } void ASTStmtWriter::VisitCastExpr(CastExpr *E) { VisitExpr(E); Record.push_back(E->path_size()); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->getCastKind()); // FIXME: stable encoding for (CastExpr::path_iterator PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI) Writer.AddCXXBaseSpecifier(**PI, Record); } void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) { VisitExpr(E); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Record.push_back(E->isFPContractable()); Code = serialization::EXPR_BINARY_OPERATOR; } void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { VisitBinaryOperator(E); Writer.AddTypeRef(E->getComputationLHSType(), Record); Writer.AddTypeRef(E->getComputationResultType(), Record); Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR; } void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) { VisitExpr(E); Writer.AddStmt(E->getCond()); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getQuestionLoc(), Record); Writer.AddSourceLocation(E->getColonLoc(), Record); Code = serialization::EXPR_CONDITIONAL_OPERATOR; } void ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { VisitExpr(E); Writer.AddStmt(E->getOpaqueValue()); Writer.AddStmt(E->getCommon()); Writer.AddStmt(E->getCond()); Writer.AddStmt(E->getTrueExpr()); Writer.AddStmt(E->getFalseExpr()); Writer.AddSourceLocation(E->getQuestionLoc(), Record); Writer.AddSourceLocation(E->getColonLoc(), Record); Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR; } void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) { VisitCastExpr(E); Code = serialization::EXPR_IMPLICIT_CAST; } void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) { VisitCastExpr(E); Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record); } void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CSTYLE_CAST; } void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddStmt(E->getInitializer()); Record.push_back(E->isFileScope()); Code = serialization::EXPR_COMPOUND_LITERAL; } void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Writer.AddIdentifierRef(&E->getAccessor(), Record); Writer.AddSourceLocation(E->getAccessorLoc(), Record); Code = serialization::EXPR_EXT_VECTOR_ELEMENT; } void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) { VisitExpr(E); // NOTE: only add the (possibly null) syntactic form. // No need to serialize the isSemanticForm flag and the semantic form. Writer.AddStmt(E->getSyntacticForm()); Writer.AddSourceLocation(E->getLBraceLoc(), Record); Writer.AddSourceLocation(E->getRBraceLoc(), Record); bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is(); Record.push_back(isArrayFiller); if (isArrayFiller) Writer.AddStmt(E->getArrayFiller()); else Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record); Record.push_back(E->hadArrayRangeDesignator()); Record.push_back(E->getNumInits()); if (isArrayFiller) { // ArrayFiller may have filled "holes" due to designated initializer. // Replace them by 0 to indicate that the filler goes in that place. Expr *filler = E->getArrayFiller(); for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : 0); } else { for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) Writer.AddStmt(E->getInit(I)); } Code = serialization::EXPR_INIT_LIST; } void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) Writer.AddStmt(E->getSubExpr(I)); Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record); Record.push_back(E->usesGNUSyntax()); for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), DEnd = E->designators_end(); D != DEnd; ++D) { if (D->isFieldDesignator()) { if (FieldDecl *Field = D->getField()) { Record.push_back(serialization::DESIG_FIELD_DECL); Writer.AddDeclRef(Field, Record); } else { Record.push_back(serialization::DESIG_FIELD_NAME); Writer.AddIdentifierRef(D->getFieldName(), Record); } Writer.AddSourceLocation(D->getDotLoc(), Record); Writer.AddSourceLocation(D->getFieldLoc(), Record); } else if (D->isArrayDesignator()) { Record.push_back(serialization::DESIG_ARRAY); Record.push_back(D->getFirstExprIndex()); Writer.AddSourceLocation(D->getLBracketLoc(), Record); Writer.AddSourceLocation(D->getRBracketLoc(), Record); } else { assert(D->isArrayRangeDesignator() && "Unknown designator"); Record.push_back(serialization::DESIG_ARRAY_RANGE); Record.push_back(D->getFirstExprIndex()); Writer.AddSourceLocation(D->getLBracketLoc(), Record); Writer.AddSourceLocation(D->getEllipsisLoc(), Record); Writer.AddSourceLocation(D->getRBracketLoc(), Record); } } Code = serialization::EXPR_DESIGNATED_INIT; } void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { VisitExpr(E); Code = serialization::EXPR_IMPLICIT_VALUE_INIT; } void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_VA_ARG; } void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getAmpAmpLoc(), Record); Writer.AddSourceLocation(E->getLabelLoc(), Record); Writer.AddDeclRef(E->getLabel(), Record); Code = serialization::EXPR_ADDR_LABEL; } void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubStmt()); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_STMT; } void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) { VisitExpr(E); Writer.AddStmt(E->getCond()); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue()); Code = serialization::EXPR_CHOOSE; } void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getTokenLocation(), Record); Code = serialization::EXPR_GNU_NULL; } void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) Writer.AddStmt(E->getExpr(I)); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_SHUFFLE_VECTOR; } void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddStmt(E->getSrcExpr()); Code = serialization::EXPR_CONVERT_VECTOR; } void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getBlockDecl(), Record); Code = serialization::EXPR_BLOCK; } void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) { VisitExpr(E); Record.push_back(E->getNumAssocs()); Writer.AddStmt(E->getControllingExpr()); for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) { Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record); Writer.AddStmt(E->getAssocExpr(I)); } Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex()); Writer.AddSourceLocation(E->getGenericLoc(), Record); Writer.AddSourceLocation(E->getDefaultLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_GENERIC_SELECTION; } void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) { VisitExpr(E); Record.push_back(E->getNumSemanticExprs()); // Push the result index. Currently, this needs to exactly match // the encoding used internally for ResultIndex. unsigned result = E->getResultExprIndex(); result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1); Record.push_back(result); Writer.AddStmt(E->getSyntacticForm()); for (PseudoObjectExpr::semantics_iterator i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) { Writer.AddStmt(*i); } Code = serialization::EXPR_PSEUDO_OBJECT; } void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) { VisitExpr(E); Record.push_back(E->getOp()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) Writer.AddStmt(E->getSubExprs()[I]); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_ATOMIC; } //===----------------------------------------------------------------------===// // Objective-C Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) { VisitExpr(E); Writer.AddStmt(E->getString()); Writer.AddSourceLocation(E->getAtLoc(), Record); Code = serialization::EXPR_OBJC_STRING_LITERAL; } void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Writer.AddDeclRef(E->getBoxingMethod(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Code = serialization::EXPR_OBJC_BOXED_EXPRESSION; } void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { VisitExpr(E); Record.push_back(E->getNumElements()); for (unsigned i = 0; i < E->getNumElements(); i++) Writer.AddStmt(E->getElement(i)); Writer.AddDeclRef(E->getArrayWithObjectsMethod(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Code = serialization::EXPR_OBJC_ARRAY_LITERAL; } void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { VisitExpr(E); Record.push_back(E->getNumElements()); Record.push_back(E->HasPackExpansions); for (unsigned i = 0; i < E->getNumElements(); i++) { ObjCDictionaryElement Element = E->getKeyValueElement(i); Writer.AddStmt(Element.Key); Writer.AddStmt(Element.Value); if (E->HasPackExpansions) { Writer.AddSourceLocation(Element.EllipsisLoc, Record); unsigned NumExpansions = 0; if (Element.NumExpansions) NumExpansions = *Element.NumExpansions + 1; Record.push_back(NumExpansions); } } Writer.AddDeclRef(E->getDictWithObjectsMethod(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL; } void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { VisitExpr(E); Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_OBJC_ENCODE; } void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { VisitExpr(E); Writer.AddSelectorRef(E->getSelector(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_OBJC_SELECTOR_EXPR; } void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getProtocol(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); Writer.AddSourceLocation(E->ProtoLoc, Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_OBJC_PROTOCOL_EXPR; } void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getDecl(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddSourceLocation(E->getOpLoc(), Record); Writer.AddStmt(E->getBase()); Record.push_back(E->isArrow()); Record.push_back(E->isFreeIvar()); Code = serialization::EXPR_OBJC_IVAR_REF_EXPR; } void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { VisitExpr(E); Record.push_back(E->SetterAndMethodRefFlags.getInt()); Record.push_back(E->isImplicitProperty()); if (E->isImplicitProperty()) { Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record); Writer.AddDeclRef(E->getImplicitPropertySetter(), Record); } else { Writer.AddDeclRef(E->getExplicitProperty(), Record); } Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddSourceLocation(E->getReceiverLocation(), Record); if (E->isObjectReceiver()) { Record.push_back(0); Writer.AddStmt(E->getBase()); } else if (E->isSuperReceiver()) { Record.push_back(1); Writer.AddTypeRef(E->getSuperReceiverType(), Record); } else { Record.push_back(2); Writer.AddDeclRef(E->getClassReceiver(), Record); } Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR; } void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getRBracket(), Record); Writer.AddStmt(E->getBaseExpr()); Writer.AddStmt(E->getKeyExpr()); Writer.AddDeclRef(E->getAtIndexMethodDecl(), Record); Writer.AddDeclRef(E->setAtIndexMethodDecl(), Record); Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR; } void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); Record.push_back(E->getNumStoredSelLocs()); Record.push_back(E->SelLocsKind); Record.push_back(E->isDelegateInitCall()); Record.push_back(E->IsImplicit); Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding switch (E->getReceiverKind()) { case ObjCMessageExpr::Instance: Writer.AddStmt(E->getInstanceReceiver()); break; case ObjCMessageExpr::Class: Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record); break; case ObjCMessageExpr::SuperClass: case ObjCMessageExpr::SuperInstance: Writer.AddTypeRef(E->getSuperType(), Record); Writer.AddSourceLocation(E->getSuperLoc(), Record); break; } if (E->getMethodDecl()) { Record.push_back(1); Writer.AddDeclRef(E->getMethodDecl(), Record); } else { Record.push_back(0); Writer.AddSelectorRef(E->getSelector(), Record); } Writer.AddSourceLocation(E->getLeftLoc(), Record); Writer.AddSourceLocation(E->getRightLoc(), Record); for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) Writer.AddStmt(*Arg); SourceLocation *Locs = E->getStoredSelLocs(); for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i) Writer.AddSourceLocation(Locs[i], Record); Code = serialization::EXPR_OBJC_MESSAGE_EXPR; } void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { VisitStmt(S); Writer.AddStmt(S->getElement()); Writer.AddStmt(S->getCollection()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_OBJC_FOR_COLLECTION; } void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { Writer.AddStmt(S->getCatchBody()); Writer.AddDeclRef(S->getCatchParamDecl(), Record); Writer.AddSourceLocation(S->getAtCatchLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_OBJC_CATCH; } void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { Writer.AddStmt(S->getFinallyBody()); Writer.AddSourceLocation(S->getAtFinallyLoc(), Record); Code = serialization::STMT_OBJC_FINALLY; } void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getAtLoc(), Record); Code = serialization::STMT_OBJC_AUTORELEASE_POOL; } void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { Record.push_back(S->getNumCatchStmts()); Record.push_back(S->getFinallyStmt() != 0); Writer.AddStmt(S->getTryBody()); for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) Writer.AddStmt(S->getCatchStmt(I)); if (S->getFinallyStmt()) Writer.AddStmt(S->getFinallyStmt()); Writer.AddSourceLocation(S->getAtTryLoc(), Record); Code = serialization::STMT_OBJC_AT_TRY; } void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { Writer.AddStmt(S->getSynchExpr()); Writer.AddStmt(S->getSynchBody()); Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record); Code = serialization::STMT_OBJC_AT_SYNCHRONIZED; } void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { Writer.AddStmt(S->getThrowExpr()); Writer.AddSourceLocation(S->getThrowLoc(), Record); Code = serialization::STMT_OBJC_AT_THROW; } void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_OBJC_BOOL_LITERAL; } //===----------------------------------------------------------------------===// // C++ Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getCatchLoc(), Record); Writer.AddDeclRef(S->getExceptionDecl(), Record); Writer.AddStmt(S->getHandlerBlock()); Code = serialization::STMT_CXX_CATCH; } void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) { VisitStmt(S); Record.push_back(S->getNumHandlers()); Writer.AddSourceLocation(S->getTryLoc(), Record); Writer.AddStmt(S->getTryBlock()); for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) Writer.AddStmt(S->getHandler(i)); Code = serialization::STMT_CXX_TRY; } void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getColonLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Writer.AddStmt(S->getRangeStmt()); Writer.AddStmt(S->getBeginEndStmt()); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getInc()); Writer.AddStmt(S->getLoopVarStmt()); Writer.AddStmt(S->getBody()); Code = serialization::STMT_CXX_FOR_RANGE; } void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getKeywordLoc(), Record); Record.push_back(S->isIfExists()); Writer.AddNestedNameSpecifierLoc(S->getQualifierLoc(), Record); Writer.AddDeclarationNameInfo(S->getNameInfo(), Record); Writer.AddStmt(S->getSubStmt()); Code = serialization::STMT_MS_DEPENDENT_EXISTS; } void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { VisitCallExpr(E); Record.push_back(E->getOperator()); Writer.AddSourceRange(E->Range, Record); Record.push_back(E->isFPContractable()); Code = serialization::EXPR_CXX_OPERATOR_CALL; } void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { VisitCallExpr(E); Code = serialization::EXPR_CXX_MEMBER_CALL; } void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) Writer.AddStmt(E->getArg(I)); Writer.AddDeclRef(E->getConstructor(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->isElidable()); Record.push_back(E->hadMultipleCandidates()); Record.push_back(E->isListInitialization()); Record.push_back(E->requiresZeroInitialization()); Record.push_back(E->getConstructionKind()); // FIXME: stable encoding Writer.AddSourceRange(E->getParenOrBraceRange(), Record); Code = serialization::EXPR_CXX_CONSTRUCT; } void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { VisitCXXConstructExpr(E); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Code = serialization::EXPR_CXX_TEMPORARY_OBJECT; } void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) { VisitExpr(E); Record.push_back(E->NumCaptures); unsigned NumArrayIndexVars = 0; if (E->HasArrayIndexVars) NumArrayIndexVars = E->getArrayIndexStarts()[E->NumCaptures]; Record.push_back(NumArrayIndexVars); Writer.AddSourceRange(E->IntroducerRange, Record); Record.push_back(E->CaptureDefault); // FIXME: stable encoding Writer.AddSourceLocation(E->CaptureDefaultLoc, Record); Record.push_back(E->ExplicitParams); Record.push_back(E->ExplicitResultType); Writer.AddSourceLocation(E->ClosingBrace, Record); // Add capture initializers. for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), CEnd = E->capture_init_end(); C != CEnd; ++C) { Writer.AddStmt(*C); } // Add array index variables, if any. if (NumArrayIndexVars) { Record.append(E->getArrayIndexStarts(), E->getArrayIndexStarts() + E->NumCaptures + 1); VarDecl **ArrayIndexVars = E->getArrayIndexVars(); for (unsigned I = 0; I != NumArrayIndexVars; ++I) Writer.AddDeclRef(ArrayIndexVars[I], Record); } Code = serialization::EXPR_LAMBDA; } void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST; } void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()), Record); Writer.AddSourceRange(E->getAngleBrackets(), Record); } void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_STATIC_CAST; } void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_DYNAMIC_CAST; } void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_REINTERPRET_CAST; } void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_CONST_CAST; } void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CXX_FUNCTIONAL_CAST; } void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) { VisitCallExpr(E); Writer.AddSourceLocation(E->UDSuffixLoc, Record); Code = serialization::EXPR_USER_DEFINED_LITERAL; } void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_CXX_BOOL_LITERAL; } void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_CXX_NULL_PTR_LITERAL; } void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { VisitExpr(E); Writer.AddSourceRange(E->getSourceRange(), Record); if (E->isTypeOperand()) { Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record); Code = serialization::EXPR_CXX_TYPEID_TYPE; } else { Writer.AddStmt(E->getExprOperand()); Code = serialization::EXPR_CXX_TYPEID_EXPR; } } void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->isImplicit()); Code = serialization::EXPR_CXX_THIS; } void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getThrowLoc(), Record); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->isThrownVariableInScope()); Code = serialization::EXPR_CXX_THROW; } void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { VisitExpr(E); bool HasOtherExprStored = E->Param.getInt(); // Store these first, the reader reads them before creation. Record.push_back(HasOtherExprStored); if (HasOtherExprStored) Writer.AddStmt(E->getExpr()); Writer.AddDeclRef(E->getParam(), Record); Writer.AddSourceLocation(E->getUsedLocation(), Record); Code = serialization::EXPR_CXX_DEFAULT_ARG; } void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getField(), Record); Writer.AddSourceLocation(E->getExprLoc(), Record); Code = serialization::EXPR_CXX_DEFAULT_INIT; } void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { VisitExpr(E); Writer.AddCXXTemporary(E->getTemporary(), Record); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_CXX_BIND_TEMPORARY; } void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { VisitExpr(E); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT; } void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) { VisitExpr(E); Record.push_back(E->isGlobalNew()); Record.push_back(E->isArray()); Record.push_back(E->doesUsualArrayDeleteWantSize()); Record.push_back(E->getNumPlacementArgs()); Record.push_back(E->StoredInitializationStyle); Writer.AddDeclRef(E->getOperatorNew(), Record); Writer.AddDeclRef(E->getOperatorDelete(), Record); Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record); Writer.AddSourceRange(E->getTypeIdParens(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddSourceRange(E->getDirectInitRange(), Record); for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end(); I != e; ++I) Writer.AddStmt(*I); Code = serialization::EXPR_CXX_NEW; } void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { VisitExpr(E); Record.push_back(E->isGlobalDelete()); Record.push_back(E->isArrayForm()); Record.push_back(E->isArrayFormAsWritten()); Record.push_back(E->doesUsualArrayDeleteWantSize()); Writer.AddDeclRef(E->getOperatorDelete(), Record); Writer.AddStmt(E->getArgument()); Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record); Code = serialization::EXPR_CXX_DELETE; } void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Record.push_back(E->isArrow()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record); Writer.AddSourceLocation(E->getColonColonLoc(), Record); Writer.AddSourceLocation(E->getTildeLoc(), Record); // PseudoDestructorTypeStorage. Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record); if (E->getDestroyedTypeIdentifier()) Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record); else Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record); Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR; } void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) { VisitExpr(E); Record.push_back(E->getNumObjects()); for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i) Writer.AddDeclRef(E->getObject(i), Record); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_EXPR_WITH_CLEANUPS; } void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ VisitExpr(E); // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo(); Record.push_back(Args.NumTemplateArgs); AddTemplateKWAndArgsInfo(Args); } if (!E->isImplicitAccess()) Writer.AddStmt(E->getBase()); else Writer.AddStmt(0); Writer.AddTypeRef(E->getBaseType(), Record); Record.push_back(E->isArrow()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record); Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record); Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER; } void ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { VisitExpr(E); // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo(); Record.push_back(Args.NumTemplateArgs); AddTemplateKWAndArgsInfo(Args); } Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddDeclarationNameInfo(E->NameInfo, Record); Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF; } void ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { VisitExpr(E); Record.push_back(E->arg_size()); for (CXXUnresolvedConstructExpr::arg_iterator ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI) Writer.AddStmt(*ArgI); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT; } void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) { VisitExpr(E); // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo(); Record.push_back(Args.NumTemplateArgs); AddTemplateKWAndArgsInfo(Args); } Record.push_back(E->getNumDecls()); for (OverloadExpr::decls_iterator OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) { Writer.AddDeclRef(OvI.getDecl(), Record); Record.push_back(OvI.getAccess()); } Writer.AddDeclarationNameInfo(E->NameInfo, Record); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); } void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { VisitOverloadExpr(E); Record.push_back(E->isArrow()); Record.push_back(E->hasUnresolvedUsing()); Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : 0); Writer.AddTypeRef(E->getBaseType(), Record); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER; } void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { VisitOverloadExpr(E); Record.push_back(E->requiresADL()); Record.push_back(E->isOverloaded()); Writer.AddDeclRef(E->getNamingClass(), Record); Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP; } void ASTStmtWriter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->getTrait()); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record); Code = serialization::EXPR_CXX_UNARY_TYPE_TRAIT; } void ASTStmtWriter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->getTrait()); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddTypeSourceInfo(E->getLhsTypeSourceInfo(), Record); Writer.AddTypeSourceInfo(E->getRhsTypeSourceInfo(), Record); Code = serialization::EXPR_BINARY_TYPE_TRAIT; } void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->TypeTraitExprBits.NumArgs); Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding Record.push_back(E->TypeTraitExprBits.Value); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) Writer.AddTypeSourceInfo(E->getArg(I), Record); Code = serialization::EXPR_TYPE_TRAIT; } void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->getTrait()); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record); Code = serialization::EXPR_ARRAY_TYPE_TRAIT; } void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { VisitExpr(E); Record.push_back(E->getTrait()); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddStmt(E->getQueriedExpression()); Code = serialization::EXPR_CXX_EXPRESSION_TRAIT; } void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddStmt(E->getOperand()); Code = serialization::EXPR_CXX_NOEXCEPT; } void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getEllipsisLoc(), Record); Record.push_back(E->NumExpansions); Writer.AddStmt(E->getPattern()); Code = serialization::EXPR_PACK_EXPANSION; } void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->OperatorLoc, Record); Writer.AddSourceLocation(E->PackLoc, Record); Writer.AddSourceLocation(E->RParenLoc, Record); Record.push_back(E->Length); Writer.AddDeclRef(E->Pack, Record); Code = serialization::EXPR_SIZEOF_PACK; } void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr( SubstNonTypeTemplateParmExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getParameter(), Record); Writer.AddSourceLocation(E->getNameLoc(), Record); Writer.AddStmt(E->getReplacement()); Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM; } void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getParameterPack(), Record); Writer.AddTemplateArgument(E->getArgumentPack(), Record); Writer.AddSourceLocation(E->getParameterPackLocation(), Record); Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK; } void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { VisitExpr(E); Record.push_back(E->getNumExpansions()); Writer.AddDeclRef(E->getParameterPack(), Record); Writer.AddSourceLocation(E->getParameterPackLocation(), Record); for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end(); I != End; ++I) Writer.AddDeclRef(*I, Record); Code = serialization::EXPR_FUNCTION_PARM_PACK; } void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { VisitExpr(E); Writer.AddStmt(E->Temporary); Writer.AddDeclRef(E->ExtendingDecl, Record); Code = serialization::EXPR_MATERIALIZE_TEMPORARY; } void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSourceExpr()); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_OPAQUE_VALUE; } //===----------------------------------------------------------------------===// // CUDA Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { VisitCallExpr(E); Writer.AddStmt(E->getConfig()); Code = serialization::EXPR_CUDA_KERNEL_CALL; } //===----------------------------------------------------------------------===// // OpenCL Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddStmt(E->getSrcExpr()); Code = serialization::EXPR_ASTYPE; } //===----------------------------------------------------------------------===// // Microsoft Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { VisitExpr(E); Record.push_back(E->isArrow()); Writer.AddStmt(E->getBaseExpr()); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddSourceLocation(E->getMemberLoc(), Record); Writer.AddDeclRef(E->getPropertyDecl(), Record); Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR; } void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) { VisitExpr(E); Writer.AddSourceRange(E->getSourceRange(), Record); if (E->isTypeOperand()) { Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record); Code = serialization::EXPR_CXX_UUIDOF_TYPE; } else { Writer.AddStmt(E->getExprOperand()); Code = serialization::EXPR_CXX_UUIDOF_EXPR; } } void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getExceptLoc(), Record); Writer.AddStmt(S->getFilterExpr()); Writer.AddStmt(S->getBlock()); Code = serialization::STMT_SEH_EXCEPT; } void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getFinallyLoc(), Record); Writer.AddStmt(S->getBlock()); Code = serialization::STMT_SEH_FINALLY; } void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) { VisitStmt(S); Record.push_back(S->getIsCXXTry()); Writer.AddSourceLocation(S->getTryLoc(), Record); Writer.AddStmt(S->getTryBlock()); Writer.AddStmt(S->getHandler()); Code = serialization::STMT_SEH_TRY; } //===----------------------------------------------------------------------===// // OpenMP Clauses. //===----------------------------------------------------------------------===// namespace clang { class OMPClauseWriter : public OMPClauseVisitor { ASTStmtWriter *Writer; ASTWriter::RecordData &Record; public: OMPClauseWriter(ASTStmtWriter *W, ASTWriter::RecordData &Record) : Writer(W), Record(Record) { } #define OPENMP_CLAUSE(Name, Class) \ void Visit##Class(Class *S); #include "clang/Basic/OpenMPKinds.def" void writeClause(OMPClause *C); }; } void OMPClauseWriter::writeClause(OMPClause *C) { Record.push_back(C->getClauseKind()); Visit(C); Writer->Writer.AddSourceLocation(C->getLocStart(), Record); Writer->Writer.AddSourceLocation(C->getLocEnd(), Record); } void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) { Record.push_back(C->getDefaultKind()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getDefaultKindKwLoc(), Record); } void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (OMPPrivateClause::varlist_iterator I = C->varlist_begin(), E = C->varlist_end(); I != E; ++I) Writer->Writer.AddStmt(*I); } void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (OMPFirstprivateClause::varlist_iterator I = C->varlist_begin(), E = C->varlist_end(); I != E; ++I) Writer->Writer.AddStmt(*I); } void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (OMPSharedClause::varlist_iterator I = C->varlist_begin(), E = C->varlist_end(); I != E; ++I) Writer->Writer.AddStmt(*I); } //===----------------------------------------------------------------------===// // OpenMP Directives. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) { VisitStmt(E); Record.push_back(E->getNumClauses()); Writer.AddSourceLocation(E->getLocStart(), Record); Writer.AddSourceLocation(E->getLocEnd(), Record); OMPClauseWriter ClauseWriter(this, Record); for (unsigned i = 0; i < E->getNumClauses(); ++i) { ClauseWriter.writeClause(E->getClause(i)); } Writer.AddStmt(E->getAssociatedStmt()); } void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE; } //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) { assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() && "SwitchCase recorded twice"); unsigned NextID = SwitchCaseIDs.size(); SwitchCaseIDs[S] = NextID; return NextID; } unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) { assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() && "SwitchCase hasn't been seen yet"); return SwitchCaseIDs[S]; } void ASTWriter::ClearSwitchCaseIDs() { SwitchCaseIDs.clear(); } /// \brief Write the given substatement or subexpression to the /// bitstream. void ASTWriter::WriteSubStmt(Stmt *S, llvm::DenseMap &SubStmtEntries, llvm::DenseSet &ParentStmts) { RecordData Record; ASTStmtWriter Writer(*this, Record); ++NumStatements; if (!S) { Stream.EmitRecord(serialization::STMT_NULL_PTR, Record); return; } llvm::DenseMap::iterator I = SubStmtEntries.find(S); if (I != SubStmtEntries.end()) { Record.push_back(I->second); Stream.EmitRecord(serialization::STMT_REF_PTR, Record); return; } #ifndef NDEBUG assert(!ParentStmts.count(S) && "There is a Stmt cycle!"); struct ParentStmtInserterRAII { Stmt *S; llvm::DenseSet &ParentStmts; ParentStmtInserterRAII(Stmt *S, llvm::DenseSet &ParentStmts) : S(S), ParentStmts(ParentStmts) { ParentStmts.insert(S); } ~ParentStmtInserterRAII() { ParentStmts.erase(S); } }; ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts); #endif // Redirect ASTWriter::AddStmt to collect sub stmts. SmallVector SubStmts; CollectedStmts = &SubStmts; Writer.Code = serialization::STMT_NULL_PTR; Writer.AbbrevToUse = 0; Writer.Visit(S); #ifndef NDEBUG if (Writer.Code == serialization::STMT_NULL_PTR) { SourceManager &SrcMgr = DeclIDs.begin()->first->getASTContext().getSourceManager(); S->dump(SrcMgr); llvm_unreachable("Unhandled sub statement writing AST file"); } #endif // Revert ASTWriter::AddStmt. CollectedStmts = &StmtsToEmit; // Write the sub stmts in reverse order, last to first. When reading them back // we will read them in correct order by "pop"ing them from the Stmts stack. // This simplifies reading and allows to store a variable number of sub stmts // without knowing it in advance. while (!SubStmts.empty()) WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts); Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse); SubStmtEntries[S] = Stream.GetCurrentBitNo(); } /// \brief Flush all of the statements that have been added to the /// queue via AddStmt(). void ASTWriter::FlushStmts() { RecordData Record; // We expect to be the only consumer of the two temporary statement maps, // assert that they are empty. assert(SubStmtEntries.empty() && "unexpected entries in sub stmt map"); assert(ParentStmts.empty() && "unexpected entries in parent stmt map"); for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts); assert(N == StmtsToEmit.size() && "Substatement written via AddStmt rather than WriteSubStmt!"); // Note that we are at the end of a full expression. Any // expression records that follow this one are part of a different // expression. Stream.EmitRecord(serialization::STMT_STOP, Record); SubStmtEntries.clear(); ParentStmts.clear(); } StmtsToEmit.clear(); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d1489 19 a1512 1 Writer.AddSourceRange(E->getSourceRange(), Record); d1815 1 a1815 1 // Redirect ASTWriter::AddStmt to collect sub-stmts. d1828 1 a1828 1 llvm_unreachable("Unhandled sub-statement writing AST file"); d1835 1 a1835 1 // Write the sub-stmts in reverse order, last to first. When reading them back d1837 1 a1837 1 // This simplifies reading and allows to store a variable number of sub-stmts d1854 1 a1854 1 assert(SubStmtEntries.empty() && "unexpected entries in sub-stmt map"); @ 1.1.1.3 log @Import Clang 3.5svn r202566. @ text @a1681 5 void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) { Writer->Writer.AddStmt(C->getCondition()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } d1719 2 a1730 2 VisitStmt(D); Record.push_back(D->getNumClauses()); a1734 8 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); Record.push_back(D->getCollapsedNumber()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_SIMD_DIRECTIVE; } @ 1.1.1.3.2.1 log @Rebase. @ text @d74 3 a76 2 for (auto *CS : S->body()) Writer.AddStmt(CS); d303 4 a306 2 for (auto *I : S->capture_inits()) Writer.AddStmt(I); d312 5 a316 3 for (const auto &I : S->captures()) { if (I.capturesThis()) Writer.AddDeclRef(nullptr, Record); d318 3 a320 3 Writer.AddDeclRef(I.getCapturedVar(), Record); Record.push_back(I.getCaptureKind()); Writer.AddSourceLocation(I.getLocation(), Record); d695 1 a695 1 Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr); d1059 1 a1059 1 Record.push_back(S->getFinallyStmt() != nullptr); d1405 1 a1405 1 Writer.AddStmt(nullptr); d1475 1 a1475 1 Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr); d1575 2 a1576 3 Writer.AddStmt(E->getTemporary()); Writer.AddDeclRef(E->getExtendingDecl(), Record); Record.push_back(E->getManglingNumber()); a1686 15 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) { Writer->Writer.AddStmt(C->getNumThreads()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) { Writer->Writer.AddStmt(C->getSafelen()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) { Writer->Writer.AddStmt(C->getNumForLoops()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } a1692 6 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) { Record.push_back(C->getProcBindKind()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getProcBindKindKwLoc(), Record); } d1696 4 a1699 2 for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); d1705 4 a1708 2 for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); d1714 4 a1717 27 for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); Writer->Writer.AddStmt(C->getStep()); } void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); Writer->Writer.AddStmt(C->getAlignment()); } void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @d74 3 a76 2 for (auto *CS : S->body()) Writer.AddStmt(CS); d303 4 a306 2 for (auto *I : S->capture_inits()) Writer.AddStmt(I); d312 5 a316 3 for (const auto &I : S->captures()) { if (I.capturesThis()) Writer.AddDeclRef(nullptr, Record); d318 3 a320 3 Writer.AddDeclRef(I.getCapturedVar(), Record); Record.push_back(I.getCaptureKind()); Writer.AddSourceLocation(I.getLocation(), Record); d695 1 a695 1 Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr); d1059 1 a1059 1 Record.push_back(S->getFinallyStmt() != nullptr); d1405 1 a1405 1 Writer.AddStmt(nullptr); d1475 1 a1475 1 Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr); d1575 2 a1576 3 Writer.AddStmt(E->getTemporary()); Writer.AddDeclRef(E->getExtendingDecl(), Record); Record.push_back(E->getManglingNumber()); a1686 15 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) { Writer->Writer.AddStmt(C->getNumThreads()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) { Writer->Writer.AddStmt(C->getSafelen()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) { Writer->Writer.AddStmt(C->getNumForLoops()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } a1692 6 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) { Record.push_back(C->getProcBindKind()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getProcBindKindKwLoc(), Record); } d1696 4 a1699 2 for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); d1705 4 a1708 2 for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); d1714 4 a1717 27 for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); Writer->Writer.AddStmt(C->getStep()); } void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); Writer->Writer.AddStmt(C->getAlignment()); } void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); @ 1.1.1.5 log @Import clang 3.6svn r215315. @ text @a637 4 if (E->path_size() == 0) AbbrevToUse = Writer.getExprImplicitCastAbbrev(); a876 1 Writer.AddDeclRef(E->getArrayAllocMethod(), Record); a898 1 Writer.AddDeclRef(E->getDictAllocMethod(), Record); a1152 1 Record.push_back(E->isStdInitListInitialization()); a1652 6 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getLeaveLoc(), Record); Code = serialization::STMT_SEH_LEAVE; } a1682 5 void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) { Writer->Writer.AddStmt(C->getCondition()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } a1709 26 void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) { Record.push_back(C->getScheduleKind()); Writer->Writer.AddStmt(C->getChunkSize()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getScheduleKindLoc(), Record); Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record); } void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *) {} void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {} void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {} void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {} void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {} void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {} void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *) {} void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {} void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {} a1723 7 void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } a1730 10 void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); Writer->Writer.AddNestedNameSpecifierLoc(C->getQualifierLoc(), Record); Writer->Writer.AddDeclarationNameInfo(C->getNameInfo(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } a1755 14 void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } d1766 1 a1766 2 if (E->hasAssociatedStmt()) Writer.AddStmt(E->getAssociatedStmt()); a1783 102 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); Record.push_back(D->getCollapsedNumber()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE; } void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_SECTION_DIRECTIVE; } void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_SINGLE_DIRECTIVE; } void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_MASTER_DIRECTIVE; } void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Writer.AddDeclarationNameInfo(D->getDirectiveName(), Record); Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE; } void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); Record.push_back(D->getCollapsedNumber()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPParallelSectionsDirective( OMPParallelSectionsDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE; } void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TASK_DIRECTIVE; } void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE; } void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE; } void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_BARRIER_DIRECTIVE; } void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE; } void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_FLUSH_DIRECTIVE; } void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_ORDERED_DIRECTIVE; } @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d310 1 a310 1 if (I.capturesThis() || I.capturesVariableArrayType()) a335 1 Writer.AddStmt(E->getFunctionName()); d346 1 a346 1 Record.push_back(E->refersToEnclosingVariableOrCapture()); d881 1 d904 1 a1582 11 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->LParenLoc, Record); Writer.AddSourceLocation(E->EllipsisLoc, Record); Writer.AddSourceLocation(E->RParenLoc, Record); Writer.AddStmt(E->SubExprs[0]); Writer.AddStmt(E->SubExprs[1]); Record.push_back(E->Opcode); Code = serialization::EXPR_CXX_FOLD; } a1589 6 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) { VisitExpr(E); // TODO: Figure out sane writer behavior for a TypoExpr, if necessary assert(false && "Cannot write TypoExpr nodes"); } d1757 1 a1757 4 for (auto *VE : C->varlists()) { Writer->Writer.AddStmt(VE); } for (auto *VE : C->private_copies()) { a1758 1 } d1764 1 a1764 1 for (auto *VE : C->varlists()) { a1765 7 } for (auto *VE : C->private_copies()) { Writer->Writer.AddStmt(VE); } for (auto *VE : C->inits()) { Writer->Writer.AddStmt(VE); } d1845 1 a1845 1 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) { a1847 1 Record.push_back(D->getCollapsedNumber()); d1849 1 a1849 26 Writer.AddStmt(D->getIterationVariable()); Writer.AddStmt(D->getLastIteration()); Writer.AddStmt(D->getCalcLastIteration()); Writer.AddStmt(D->getPreCond()); Writer.AddStmt(D->getCond(/* SeparateIter */ false)); Writer.AddStmt(D->getCond(/* SeparateIter */ true)); Writer.AddStmt(D->getInit()); Writer.AddStmt(D->getInc()); if (isOpenMPWorksharingDirective(D->getDirectiveKind())) { Writer.AddStmt(D->getIsLastIterVariable()); Writer.AddStmt(D->getLowerBoundVariable()); Writer.AddStmt(D->getUpperBoundVariable()); Writer.AddStmt(D->getStrideVariable()); Writer.AddStmt(D->getEnsureUpperBound()); Writer.AddStmt(D->getNextLowerBound()); Writer.AddStmt(D->getNextUpperBound()); } for (auto I : D->counters()) { Writer.AddStmt(I); } for (auto I : D->updates()) { Writer.AddStmt(I); } for (auto I : D->finals()) { Writer.AddStmt(I); } d1852 1 a1852 1 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { d1855 1 a1856 5 Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE; } void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { VisitOMPLoopDirective(D); d1861 4 a1864 1 VisitOMPLoopDirective(D); a1867 5 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE; } d1902 4 a1905 1 VisitOMPLoopDirective(D); a1908 6 void ASTStmtWriter::VisitOMPParallelForSimdDirective( OMPParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE; } a1927 3 Writer.AddStmt(D->getX()); Writer.AddStmt(D->getV()); Writer.AddStmt(D->getExpr()); a1930 7 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_DIRECTIVE; } a1961 7 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TEAMS_DIRECTIVE; } @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @d310 1 a310 1 if (I.capturesThis() || I.capturesVariableArrayType()) a335 1 Writer.AddStmt(E->getFunctionName()); d346 1 a346 1 Record.push_back(E->refersToEnclosingVariableOrCapture()); d881 1 d904 1 a1582 11 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->LParenLoc, Record); Writer.AddSourceLocation(E->EllipsisLoc, Record); Writer.AddSourceLocation(E->RParenLoc, Record); Writer.AddStmt(E->SubExprs[0]); Writer.AddStmt(E->SubExprs[1]); Record.push_back(E->Opcode); Code = serialization::EXPR_CXX_FOLD; } a1589 6 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) { VisitExpr(E); // TODO: Figure out sane writer behavior for a TypoExpr, if necessary assert(false && "Cannot write TypoExpr nodes"); } d1757 1 a1757 4 for (auto *VE : C->varlists()) { Writer->Writer.AddStmt(VE); } for (auto *VE : C->private_copies()) { a1758 1 } d1764 1 a1764 1 for (auto *VE : C->varlists()) { a1765 7 } for (auto *VE : C->private_copies()) { Writer->Writer.AddStmt(VE); } for (auto *VE : C->inits()) { Writer->Writer.AddStmt(VE); } d1845 1 a1845 1 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) { a1847 1 Record.push_back(D->getCollapsedNumber()); d1849 1 a1849 26 Writer.AddStmt(D->getIterationVariable()); Writer.AddStmt(D->getLastIteration()); Writer.AddStmt(D->getCalcLastIteration()); Writer.AddStmt(D->getPreCond()); Writer.AddStmt(D->getCond(/* SeparateIter */ false)); Writer.AddStmt(D->getCond(/* SeparateIter */ true)); Writer.AddStmt(D->getInit()); Writer.AddStmt(D->getInc()); if (isOpenMPWorksharingDirective(D->getDirectiveKind())) { Writer.AddStmt(D->getIsLastIterVariable()); Writer.AddStmt(D->getLowerBoundVariable()); Writer.AddStmt(D->getUpperBoundVariable()); Writer.AddStmt(D->getStrideVariable()); Writer.AddStmt(D->getEnsureUpperBound()); Writer.AddStmt(D->getNextLowerBound()); Writer.AddStmt(D->getNextUpperBound()); } for (auto I : D->counters()) { Writer.AddStmt(I); } for (auto I : D->updates()) { Writer.AddStmt(I); } for (auto I : D->finals()) { Writer.AddStmt(I); } d1852 1 a1852 1 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { d1855 1 a1856 5 Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE; } void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { VisitOMPLoopDirective(D); d1861 4 a1864 1 VisitOMPLoopDirective(D); a1867 5 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE; } d1902 4 a1905 1 VisitOMPLoopDirective(D); a1908 6 void ASTStmtWriter::VisitOMPParallelForSimdDirective( OMPParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE; } a1927 3 Writer.AddStmt(D->getX()); Writer.AddStmt(D->getV()); Writer.AddStmt(D->getExpr()); a1930 7 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_DIRECTIVE; } a1961 7 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TEAMS_DIRECTIVE; } @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @d43 1 a43 2 void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args); d52 7 a58 7 void ASTStmtWriter::AddTemplateKWAndArgsInfo( const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) { Writer.AddSourceLocation(ArgInfo.TemplateKWLoc, Record); Writer.AddSourceLocation(ArgInfo.LAngleLoc, Record); Writer.AddSourceLocation(ArgInfo.RAngleLoc, Record); for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i) Writer.AddTemplateArgumentLoc(Args[i], Record); a289 20 void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { // FIXME: Implement coroutine serialization. llvm_unreachable("unimplemented"); } void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) { // FIXME: Implement coroutine serialization. llvm_unreachable("unimplemented"); } void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *S) { // FIXME: Implement coroutine serialization. llvm_unreachable("unimplemented"); } void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *S) { // FIXME: Implement coroutine serialization. llvm_unreachable("unimplemented"); } d369 1 a369 2 AddTemplateKWAndArgsInfo(*E->getTrailingObjects(), E->getTrailingObjects()); d465 1 a465 1 const OffsetOfNode &ON = E->getComponent(I); d470 1 a470 1 case OffsetOfNode::Array: d473 2 a474 2 case OffsetOfNode::Field: d477 2 a478 2 case OffsetOfNode::Identifier: d481 2 a482 2 case OffsetOfNode::Base: a513 10 void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Writer.AddStmt(E->getLowerBound()); Writer.AddStmt(E->getLength()); Writer.AddSourceLocation(E->getColonLoc(), Record); Writer.AddSourceLocation(E->getRBracketLoc(), Record); Code = serialization::EXPR_OMP_ARRAY_SECTION; } a555 1 Writer.AddSourceLocation(E->getOperatorLoc(), Record); a739 12 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Writer.AddStmt(E->getUpdater()); Code = serialization::EXPR_DESIGNATED_INIT_UPDATE; } void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) { VisitExpr(E); Code = serialization::EXPR_NO_INIT; } a750 1 Record.push_back(E->isMicrosoftABI()); a1113 1 Writer.AddSourceLocation(S->getCoawaitLoc(), Record); d1292 6 d1300 1 d1398 3 a1400 5 const ASTTemplateKWAndArgsInfo &ArgInfo = *E->getTrailingObjects(); Record.push_back(ArgInfo.NumTemplateArgs); AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingObjects()); d1425 3 a1427 5 const ASTTemplateKWAndArgsInfo &ArgInfo = *E->getTrailingObjects(); Record.push_back(ArgInfo.NumTemplateArgs); AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingObjects()); d1456 3 a1458 4 const ASTTemplateKWAndArgsInfo &ArgInfo = *E->getTrailingASTTemplateKWAndArgsInfo(); Record.push_back(ArgInfo.NumTemplateArgs); AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc()); a1536 2 Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size() : 0); d1540 1 a1541 6 if (E->isPartiallySubstituted()) { for (const auto &TA : E->getPartialArguments()) Writer.AddTemplateArgument(TA, Record); } else if (!E->isValueDependent()) { Record.push_back(E->getPackLength()); } a1639 8 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Writer.AddStmt(E->getIdx()); Writer.AddSourceLocation(E->getRBracketLoc(), Record); Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR; } a1707 3 Record.push_back(C->getNameModifier()); Writer->Writer.AddSourceLocation(C->getNameModifierLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); a1726 5 void OMPClauseWriter::VisitOMPSimdlenClause(OMPSimdlenClause *C) { Writer->Writer.AddStmt(C->getSimdlen()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } a1745 2 Record.push_back(C->getFirstScheduleModifier()); Record.push_back(C->getSecondScheduleModifier()); a1746 1 Writer->Writer.AddStmt(C->getHelperChunkSize()); a1747 2 Writer->Writer.AddSourceLocation(C->getFirstScheduleModifierLoc(), Record); Writer->Writer.AddSourceLocation(C->getSecondScheduleModifierLoc(), Record); d1752 1 a1752 4 void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *C) { Writer->Writer.AddStmt(C->getNumForLoops()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } a1769 6 void OMPClauseWriter::VisitOMPThreadsClause(OMPThreadsClause *) {} void OMPClauseWriter::VisitOMPSIMDClause(OMPSIMDClause *) {} void OMPClauseWriter::VisitOMPNogroupClause(OMPNogroupClause *) {} a1799 8 for (auto *E : C->private_copies()) Writer->Writer.AddStmt(E); for (auto *E : C->source_exprs()) Writer->Writer.AddStmt(E); for (auto *E : C->destination_exprs()) Writer->Writer.AddStmt(E); for (auto *E : C->assignment_ops()) Writer->Writer.AddStmt(E); a1816 8 for (auto *VE : C->privates()) Writer->Writer.AddStmt(VE); for (auto *E : C->lhs_exprs()) Writer->Writer.AddStmt(E); for (auto *E : C->rhs_exprs()) Writer->Writer.AddStmt(E); for (auto *E : C->reduction_ops()) Writer->Writer.AddStmt(E); d1823 1 a1823 3 Record.push_back(C->getModifier()); Writer->Writer.AddSourceLocation(C->getModifierLoc(), Record); for (auto *VE : C->varlists()) { a1824 13 } for (auto *VE : C->privates()) { Writer->Writer.AddStmt(VE); } for (auto *VE : C->inits()) { Writer->Writer.AddStmt(VE); } for (auto *VE : C->updates()) { Writer->Writer.AddStmt(VE); } for (auto *VE : C->finals()) { Writer->Writer.AddStmt(VE); } a1825 1 Writer->Writer.AddStmt(C->getCalcStep()); a1841 6 for (auto *E : C->source_exprs()) Writer->Writer.AddStmt(E); for (auto *E : C->destination_exprs()) Writer->Writer.AddStmt(E); for (auto *E : C->assignment_ops()) Writer->Writer.AddStmt(E); a1848 6 for (auto *E : C->source_exprs()) Writer->Writer.AddStmt(E); for (auto *E : C->destination_exprs()) Writer->Writer.AddStmt(E); for (auto *E : C->assignment_ops()) Writer->Writer.AddStmt(E); a1857 56 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Record.push_back(C->getDependencyKind()); Writer->Writer.AddSourceLocation(C->getDependencyLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPDeviceClause(OMPDeviceClause *C) { Writer->Writer.AddStmt(C->getDevice()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPMapClause(OMPMapClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Record.push_back(C->getMapTypeModifier()); Record.push_back(C->getMapType()); Writer->Writer.AddSourceLocation(C->getMapLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) { Writer->Writer.AddStmt(C->getNumTeams()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) { Writer->Writer.AddStmt(C->getThreadLimit()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPPriorityClause(OMPPriorityClause *C) { Writer->Writer.AddStmt(C->getPriority()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) { Writer->Writer.AddStmt(C->getGrainsize()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPNumTasksClause(OMPNumTasksClause *C) { Writer->Writer.AddStmt(C->getNumTasks()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPHintClause(OMPHintClause *C) { Writer->Writer.AddStmt(C->getHint()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } d1881 2 a1882 1 Writer.AddStmt(D->getCond()); a1896 6 for (auto I : D->private_counters()) { Writer.AddStmt(I); } for (auto I : D->inits()) { Writer.AddStmt(I); } a1908 1 Record.push_back(D->hasCancel() ? 1 : 0); a1918 1 Record.push_back(D->hasCancel() ? 1 : 0); a1930 1 Record.push_back(D->hasCancel() ? 1 : 0); a1936 1 Record.push_back(D->hasCancel() ? 1 : 0); a1954 1 Record.push_back(D->getNumClauses()); a1961 1 Record.push_back(D->hasCancel() ? 1 : 0); a1975 1 Record.push_back(D->hasCancel() ? 1 : 0); a1982 1 Record.push_back(D->hasCancel() ? 1 : 0); a1992 3 Writer.AddStmt(D->getUpdateExpr()); Record.push_back(D->isXLHSInRHSPart() ? 1 : 0); Record.push_back(D->isPostfixUpdate() ? 1 : 0); a2002 7 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE; } a2020 6 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE; } a2029 1 Record.push_back(D->getNumClauses()); a2040 31 void ASTStmtWriter::VisitOMPCancellationPointDirective( OMPCancellationPointDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Record.push_back(D->getCancelRegion()); Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE; } void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Record.push_back(D->getCancelRegion()); Code = serialization::STMT_OMP_CANCEL_DIRECTIVE; } void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE; } void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE; } @ 1.1.1.7.2.1 log @Sync with HEAD @ text @d32 1 d34 1 a34 1 ASTRecordWriter Record; d36 1 a39 1 public: d41 1 a41 10 : Writer(Writer), Record(Writer, Record), Code(serialization::STMT_NULL_PTR), AbbrevToUse(0) {} ASTStmtWriter(const ASTStmtWriter&) = delete; uint64_t Emit() { assert(Code != serialization::STMT_NULL_PTR && "unhandled sub-statement writing AST file"); return Record.EmitStmt(Code, AbbrevToUse); } d55 3 a57 3 Record.AddSourceLocation(ArgInfo.TemplateKWLoc); Record.AddSourceLocation(ArgInfo.LAngleLoc); Record.AddSourceLocation(ArgInfo.RAngleLoc); d59 1 a59 1 Record.AddTemplateArgumentLoc(Args[i]); d67 1 a67 1 Record.AddSourceLocation(S->getSemiLoc()); d76 3 a78 3 Record.AddStmt(CS); Record.AddSourceLocation(S->getLBracLoc()); Record.AddSourceLocation(S->getRBracLoc()); d85 2 a86 2 Record.AddSourceLocation(S->getKeywordLoc()); Record.AddSourceLocation(S->getColonLoc()); d91 4 a94 4 Record.AddStmt(S->getLHS()); Record.AddStmt(S->getRHS()); Record.AddStmt(S->getSubStmt()); Record.AddSourceLocation(S->getEllipsisLoc()); d100 1 a100 1 Record.AddStmt(S->getSubStmt()); d106 3 a108 3 Record.AddDeclRef(S->getDecl()); Record.AddStmt(S->getSubStmt()); Record.AddSourceLocation(S->getIdentLoc()); d115 3 a117 3 Record.AddAttributes(S->getAttrs()); Record.AddStmt(S->getSubStmt()); Record.AddSourceLocation(S->getAttrLoc()); d123 6 a128 8 Record.push_back(S->isConstexpr()); Record.AddStmt(S->getInit()); Record.AddDeclRef(S->getConditionVariable()); Record.AddStmt(S->getCond()); Record.AddStmt(S->getThen()); Record.AddStmt(S->getElse()); Record.AddSourceLocation(S->getIfLoc()); Record.AddSourceLocation(S->getElseLoc()); d134 4 a137 5 Record.AddStmt(S->getInit()); Record.AddDeclRef(S->getConditionVariable()); Record.AddStmt(S->getCond()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getSwitchLoc()); d147 4 a150 4 Record.AddDeclRef(S->getConditionVariable()); Record.AddStmt(S->getCond()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getWhileLoc()); d156 5 a160 5 Record.AddStmt(S->getCond()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getDoLoc()); Record.AddSourceLocation(S->getWhileLoc()); Record.AddSourceLocation(S->getRParenLoc()); d166 8 a173 8 Record.AddStmt(S->getInit()); Record.AddStmt(S->getCond()); Record.AddDeclRef(S->getConditionVariable()); Record.AddStmt(S->getInc()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getForLoc()); Record.AddSourceLocation(S->getLParenLoc()); Record.AddSourceLocation(S->getRParenLoc()); d179 3 a181 3 Record.AddDeclRef(S->getLabel()); Record.AddSourceLocation(S->getGotoLoc()); Record.AddSourceLocation(S->getLabelLoc()); d187 3 a189 3 Record.AddSourceLocation(S->getGotoLoc()); Record.AddSourceLocation(S->getStarLoc()); Record.AddStmt(S->getTarget()); d195 1 a195 1 Record.AddSourceLocation(S->getContinueLoc()); d201 1 a201 1 Record.AddSourceLocation(S->getBreakLoc()); d207 3 a209 3 Record.AddStmt(S->getRetValue()); Record.AddSourceLocation(S->getReturnLoc()); Record.AddDeclRef(S->getNRVOCandidate()); d215 2 a216 2 Record.AddSourceLocation(S->getStartLoc()); Record.AddSourceLocation(S->getEndLoc()); d219 1 a219 1 Record.AddDeclRef(*D); d228 1 a228 1 Record.AddSourceLocation(S->getAsmLoc()); d235 2 a236 2 Record.AddSourceLocation(S->getRParenLoc()); Record.AddStmt(S->getAsmString()); d240 3 a242 3 Record.AddIdentifierRef(S->getOutputIdentifier(I)); Record.AddStmt(S->getOutputConstraintLiteral(I)); Record.AddStmt(S->getOutputExpr(I)); d247 3 a249 3 Record.AddIdentifierRef(S->getInputIdentifier(I)); Record.AddStmt(S->getInputConstraintLiteral(I)); Record.AddStmt(S->getInputExpr(I)); d254 1 a254 1 Record.AddStmt(S->getClobberStringLiteral(I)); d261 2 a262 2 Record.AddSourceLocation(S->getLBraceLoc()); Record.AddSourceLocation(S->getEndLoc()); d264 1 a264 1 Record.AddString(S->getAsmString()); d268 1 a268 2 // FIXME: Move this to ASTRecordWriter? Writer.AddToken(S->getAsmToks()[I], Record.getRecordData()); d273 1 a273 1 Record.AddString(S->getClobber(I)); d278 2 a279 2 Record.AddStmt(S->getOutputExpr(I)); Record.AddString(S->getOutputConstraint(I)); d284 2 a285 2 Record.AddStmt(S->getInputExpr(I)); Record.AddString(S->getInputConstraint(I)); d317 1 a317 1 Record.AddDeclRef(S->getCapturedDecl()); d320 1 a320 1 Record.AddDeclRef(S->getCapturedRecordDecl()); d324 1 a324 1 Record.AddStmt(I); d327 1 a327 1 Record.AddStmt(S->getCapturedStmt()); d332 1 a332 1 Record.AddDeclRef(nullptr); d334 1 a334 1 Record.AddDeclRef(I.getCapturedVar()); d336 1 a336 1 Record.AddSourceLocation(I.getLocation()); d344 1 a344 1 Record.AddTypeRef(E->getType()); d355 1 a355 1 Record.AddSourceLocation(E->getLocation()); d357 1 a357 1 Record.AddStmt(E->getFunctionName()); d384 1 a384 1 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); d387 1 a387 1 Record.AddDeclRef(E->getFoundDecl()); d393 3 a395 3 Record.AddDeclRef(E->getDecl()); Record.AddSourceLocation(E->getLocation()); Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName()); d401 2 a402 2 Record.AddSourceLocation(E->getLocation()); Record.AddAPInt(E->getValue()); d415 2 a416 2 Record.AddAPFloat(E->getValue()); Record.AddSourceLocation(E->getLocation()); d422 1 a422 1 Record.AddStmt(E->getSubExpr()); d438 1 a438 1 Record.AddSourceLocation(E->getStrTokenLoc(I)); d445 1 a445 1 Record.AddSourceLocation(E->getLocation()); d455 3 a457 3 Record.AddSourceLocation(E->getLParen()); Record.AddSourceLocation(E->getRParen()); Record.AddStmt(E->getSubExpr()); d465 3 a467 3 Record.AddStmt(E->Exprs[i]); Record.AddSourceLocation(E->LParenLoc); Record.AddSourceLocation(E->RParenLoc); d473 1 a473 1 Record.AddStmt(E->getSubExpr()); d475 1 a475 1 Record.AddSourceLocation(E->getOperatorLoc()); d483 3 a485 3 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddSourceLocation(E->getRParenLoc()); Record.AddTypeSourceInfo(E->getTypeSourceInfo()); d489 2 a490 2 Record.AddSourceLocation(ON.getSourceRange().getBegin()); Record.AddSourceLocation(ON.getSourceRange().getEnd()); d497 1 a497 1 Record.AddDeclRef(ON.getField()); d501 1 a501 1 Record.AddIdentifierRef(ON.getFieldName()); d505 1 a505 1 Record.AddCXXBaseSpecifier(*ON.getBase()); d510 1 a510 1 Record.AddStmt(E->getIndexExpr(I)); d518 1 a518 1 Record.AddTypeSourceInfo(E->getArgumentTypeInfo()); d521 1 a521 1 Record.AddStmt(E->getArgumentExpr()); d523 2 a524 2 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddSourceLocation(E->getRParenLoc()); d530 3 a532 3 Record.AddStmt(E->getLHS()); Record.AddStmt(E->getRHS()); Record.AddSourceLocation(E->getRBracketLoc()); d538 5 a542 5 Record.AddStmt(E->getBase()); Record.AddStmt(E->getLowerBound()); Record.AddStmt(E->getLength()); Record.AddSourceLocation(E->getColonLoc()); Record.AddSourceLocation(E->getRBracketLoc()); d549 2 a550 2 Record.AddSourceLocation(E->getRParenLoc()); Record.AddStmt(E->getCallee()); d553 1 a553 1 Record.AddStmt(*Arg); d562 1 a562 1 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); d566 1 a566 1 Record.AddSourceLocation(E->getTemplateKeywordLoc()); d569 2 a570 2 Record.AddSourceLocation(E->getLAngleLoc()); Record.AddSourceLocation(E->getRAngleLoc()); d572 1 a572 1 Record.AddTemplateArgumentLoc(E->getTemplateArgs()[i]); d578 1 a578 1 Record.AddDeclRef(FoundDecl.getDecl()); d581 1 a581 1 Record.AddTypeRef(E->getType()); d584 3 a586 3 Record.AddStmt(E->getBase()); Record.AddDeclRef(E->getMemberDecl()); Record.AddSourceLocation(E->getMemberLoc()); d588 3 a590 3 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddDeclarationNameLoc(E->MemberDNLoc, E->getMemberDecl()->getDeclName()); d596 3 a598 3 Record.AddStmt(E->getBase()); Record.AddSourceLocation(E->getIsaMemberLoc()); Record.AddSourceLocation(E->getOpLoc()); d606 1 a606 1 Record.AddStmt(E->getSubExpr()); d613 2 a614 2 Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getBridgeKeywordLoc()); d622 1 a622 1 Record.AddStmt(E->getSubExpr()); d627 1 a627 1 Record.AddCXXBaseSpecifier(**PI); d632 2 a633 2 Record.AddStmt(E->getLHS()); Record.AddStmt(E->getRHS()); d635 1 a635 1 Record.AddSourceLocation(E->getOperatorLoc()); d642 2 a643 2 Record.AddTypeRef(E->getComputationLHSType()); Record.AddTypeRef(E->getComputationResultType()); d649 5 a653 5 Record.AddStmt(E->getCond()); Record.AddStmt(E->getLHS()); Record.AddStmt(E->getRHS()); Record.AddSourceLocation(E->getQuestionLoc()); Record.AddSourceLocation(E->getColonLoc()); d660 7 a666 7 Record.AddStmt(E->getOpaqueValue()); Record.AddStmt(E->getCommon()); Record.AddStmt(E->getCond()); Record.AddStmt(E->getTrueExpr()); Record.AddStmt(E->getFalseExpr()); Record.AddSourceLocation(E->getQuestionLoc()); Record.AddSourceLocation(E->getColonLoc()); d681 1 a681 1 Record.AddTypeSourceInfo(E->getTypeInfoAsWritten()); d686 2 a687 2 Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getRParenLoc()); d693 3 a695 3 Record.AddSourceLocation(E->getLParenLoc()); Record.AddTypeSourceInfo(E->getTypeSourceInfo()); Record.AddStmt(E->getInitializer()); d702 3 a704 3 Record.AddStmt(E->getBase()); Record.AddIdentifierRef(&E->getAccessor()); Record.AddSourceLocation(E->getAccessorLoc()); d712 3 a714 3 Record.AddStmt(E->getSyntacticForm()); Record.AddSourceLocation(E->getLBraceLoc()); Record.AddSourceLocation(E->getRBraceLoc()); d718 1 a718 1 Record.AddStmt(E->getArrayFiller()); d720 1 a720 1 Record.AddDeclRef(E->getInitializedFieldInUnion()); d728 1 a728 1 Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr); d731 1 a731 1 Record.AddStmt(E->getInit(I)); d740 2 a741 2 Record.AddStmt(E->getSubExpr(I)); Record.AddSourceLocation(E->getEqualOrColonLoc()); d743 5 a747 3 for (const DesignatedInitExpr::Designator &D : E->designators()) { if (D.isFieldDesignator()) { if (FieldDecl *Field = D.getField()) { d749 1 a749 1 Record.AddDeclRef(Field); d752 1 a752 1 Record.AddIdentifierRef(D.getFieldName()); d754 3 a756 3 Record.AddSourceLocation(D.getDotLoc()); Record.AddSourceLocation(D.getFieldLoc()); } else if (D.isArrayDesignator()) { d758 3 a760 3 Record.push_back(D.getFirstExprIndex()); Record.AddSourceLocation(D.getLBracketLoc()); Record.AddSourceLocation(D.getRBracketLoc()); d762 1 a762 1 assert(D.isArrayRangeDesignator() && "Unknown designator"); d764 4 a767 4 Record.push_back(D.getFirstExprIndex()); Record.AddSourceLocation(D.getLBracketLoc()); Record.AddSourceLocation(D.getEllipsisLoc()); Record.AddSourceLocation(D.getRBracketLoc()); d775 2 a776 2 Record.AddStmt(E->getBase()); Record.AddStmt(E->getUpdater()); a784 12 void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { VisitExpr(E); Record.AddStmt(E->SubExprs[0]); Record.AddStmt(E->SubExprs[1]); Code = serialization::EXPR_ARRAY_INIT_LOOP; } void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { VisitExpr(E); Code = serialization::EXPR_ARRAY_INIT_INDEX; } d792 4 a795 4 Record.AddStmt(E->getSubExpr()); Record.AddTypeSourceInfo(E->getWrittenTypeInfo()); Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); d802 3 a804 3 Record.AddSourceLocation(E->getAmpAmpLoc()); Record.AddSourceLocation(E->getLabelLoc()); Record.AddDeclRef(E->getLabel()); d810 3 a812 3 Record.AddStmt(E->getSubStmt()); Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getRParenLoc()); d818 5 a822 5 Record.AddStmt(E->getCond()); Record.AddStmt(E->getLHS()); Record.AddStmt(E->getRHS()); Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); d829 1 a829 1 Record.AddSourceLocation(E->getTokenLocation()); d837 3 a839 3 Record.AddStmt(E->getExpr(I)); Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); d845 4 a848 4 Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); Record.AddTypeSourceInfo(E->getTypeSourceInfo()); Record.AddStmt(E->getSrcExpr()); d854 1 a854 1 Record.AddDeclRef(E->getBlockDecl()); d862 1 a862 1 Record.AddStmt(E->getControllingExpr()); d864 2 a865 2 Record.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I)); Record.AddStmt(E->getAssocExpr(I)); d869 3 a871 3 Record.AddSourceLocation(E->getGenericLoc()); Record.AddSourceLocation(E->getDefaultLoc()); Record.AddSourceLocation(E->getRParenLoc()); d885 1 a885 1 Record.AddStmt(E->getSyntacticForm()); d888 1 a888 1 Record.AddStmt(*i); d897 3 a899 3 Record.AddStmt(E->getSubExprs()[I]); Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); d909 2 a910 2 Record.AddStmt(E->getString()); Record.AddSourceLocation(E->getAtLoc()); d916 3 a918 3 Record.AddStmt(E->getSubExpr()); Record.AddDeclRef(E->getBoxingMethod()); Record.AddSourceRange(E->getSourceRange()); d926 3 a928 3 Record.AddStmt(E->getElement(i)); Record.AddDeclRef(E->getArrayWithObjectsMethod()); Record.AddSourceRange(E->getSourceRange()); d938 2 a939 2 Record.AddStmt(Element.Key); Record.AddStmt(Element.Value); d941 1 a941 1 Record.AddSourceLocation(Element.EllipsisLoc); d949 2 a950 2 Record.AddDeclRef(E->getDictWithObjectsMethod()); Record.AddSourceRange(E->getSourceRange()); d956 3 a958 3 Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo()); Record.AddSourceLocation(E->getAtLoc()); Record.AddSourceLocation(E->getRParenLoc()); d964 3 a966 3 Record.AddSelectorRef(E->getSelector()); Record.AddSourceLocation(E->getAtLoc()); Record.AddSourceLocation(E->getRParenLoc()); d972 4 a975 4 Record.AddDeclRef(E->getProtocol()); Record.AddSourceLocation(E->getAtLoc()); Record.AddSourceLocation(E->ProtoLoc); Record.AddSourceLocation(E->getRParenLoc()); d981 4 a984 4 Record.AddDeclRef(E->getDecl()); Record.AddSourceLocation(E->getLocation()); Record.AddSourceLocation(E->getOpLoc()); Record.AddStmt(E->getBase()); d995 2 a996 2 Record.AddDeclRef(E->getImplicitPropertyGetter()); Record.AddDeclRef(E->getImplicitPropertySetter()); d998 1 a998 1 Record.AddDeclRef(E->getExplicitProperty()); d1000 2 a1001 2 Record.AddSourceLocation(E->getLocation()); Record.AddSourceLocation(E->getReceiverLocation()); d1004 1 a1004 1 Record.AddStmt(E->getBase()); d1007 1 a1007 1 Record.AddTypeRef(E->getSuperReceiverType()); d1010 1 a1010 1 Record.AddDeclRef(E->getClassReceiver()); d1018 5 a1022 5 Record.AddSourceLocation(E->getRBracket()); Record.AddStmt(E->getBaseExpr()); Record.AddStmt(E->getKeyExpr()); Record.AddDeclRef(E->getAtIndexMethodDecl()); Record.AddDeclRef(E->setAtIndexMethodDecl()); d1037 1 a1037 1 Record.AddStmt(E->getInstanceReceiver()); d1041 1 a1041 1 Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo()); d1046 2 a1047 2 Record.AddTypeRef(E->getSuperType()); Record.AddSourceLocation(E->getSuperLoc()); d1053 1 a1053 1 Record.AddDeclRef(E->getMethodDecl()); d1056 1 a1056 1 Record.AddSelectorRef(E->getSelector()); d1059 2 a1060 2 Record.AddSourceLocation(E->getLeftLoc()); Record.AddSourceLocation(E->getRightLoc()); d1064 1 a1064 1 Record.AddStmt(*Arg); d1068 1 a1068 1 Record.AddSourceLocation(Locs[i]); d1075 5 a1079 5 Record.AddStmt(S->getElement()); Record.AddStmt(S->getCollection()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getForLoc()); Record.AddSourceLocation(S->getRParenLoc()); d1084 4 a1087 4 Record.AddStmt(S->getCatchBody()); Record.AddDeclRef(S->getCatchParamDecl()); Record.AddSourceLocation(S->getAtCatchLoc()); Record.AddSourceLocation(S->getRParenLoc()); d1092 2 a1093 2 Record.AddStmt(S->getFinallyBody()); Record.AddSourceLocation(S->getAtFinallyLoc()); d1098 2 a1099 2 Record.AddStmt(S->getSubStmt()); Record.AddSourceLocation(S->getAtLoc()); d1106 1 a1106 1 Record.AddStmt(S->getTryBody()); d1108 1 a1108 1 Record.AddStmt(S->getCatchStmt(I)); d1110 2 a1111 2 Record.AddStmt(S->getFinallyStmt()); Record.AddSourceLocation(S->getAtTryLoc()); d1116 3 a1118 3 Record.AddStmt(S->getSynchExpr()); Record.AddStmt(S->getSynchBody()); Record.AddSourceLocation(S->getAtSynchronizedLoc()); d1123 2 a1124 2 Record.AddStmt(S->getThrowExpr()); Record.AddSourceLocation(S->getThrowLoc()); d1131 1 a1131 1 Record.AddSourceLocation(E->getLocation()); a1134 7 void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) { VisitExpr(E); Record.AddSourceRange(E->getSourceRange()); Record.AddVersionTuple(E->getVersion()); Code = serialization::EXPR_OBJC_AVAILABILITY_CHECK; } d1141 3 a1143 3 Record.AddSourceLocation(S->getCatchLoc()); Record.AddDeclRef(S->getExceptionDecl()); Record.AddStmt(S->getHandlerBlock()); d1150 2 a1151 2 Record.AddSourceLocation(S->getTryLoc()); Record.AddStmt(S->getTryBlock()); d1153 1 a1153 1 Record.AddStmt(S->getHandler(i)); d1159 10 a1168 11 Record.AddSourceLocation(S->getForLoc()); Record.AddSourceLocation(S->getCoawaitLoc()); Record.AddSourceLocation(S->getColonLoc()); Record.AddSourceLocation(S->getRParenLoc()); Record.AddStmt(S->getRangeStmt()); Record.AddStmt(S->getBeginStmt()); Record.AddStmt(S->getEndStmt()); Record.AddStmt(S->getCond()); Record.AddStmt(S->getInc()); Record.AddStmt(S->getLoopVarStmt()); Record.AddStmt(S->getBody()); d1174 1 a1174 1 Record.AddSourceLocation(S->getKeywordLoc()); d1176 3 a1178 3 Record.AddNestedNameSpecifierLoc(S->getQualifierLoc()); Record.AddDeclarationNameInfo(S->getNameInfo()); Record.AddStmt(S->getSubStmt()); d1185 1 a1185 1 Record.AddSourceRange(E->Range); d1199 3 a1201 3 Record.AddStmt(E->getArg(I)); Record.AddDeclRef(E->getConstructor()); Record.AddSourceLocation(E->getLocation()); d1208 1 a1208 1 Record.AddSourceRange(E->getParenOrBraceRange()); a1211 9 void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { VisitExpr(E); Record.AddDeclRef(E->getConstructor()); Record.AddSourceLocation(E->getLocation()); Record.push_back(E->constructsVBase()); Record.push_back(E->inheritedFromVBase()); Code = serialization::EXPR_CXX_INHERITED_CTOR_INIT; } d1214 1 a1214 1 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); d1221 5 a1225 1 Record.AddSourceRange(E->IntroducerRange); d1227 1 a1227 1 Record.AddSourceLocation(E->CaptureDefaultLoc); d1230 1 a1230 1 Record.AddSourceLocation(E->ClosingBrace); d1236 10 a1245 1 Record.AddStmt(*C); d1253 1 a1253 1 Record.AddStmt(E->getSubExpr()); d1259 3 a1261 2 Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc())); Record.AddSourceRange(E->getAngleBrackets()); d1286 2 a1287 2 Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getRParenLoc()); d1293 1 a1293 1 Record.AddSourceLocation(E->UDSuffixLoc); d1300 1 a1300 1 Record.AddSourceLocation(E->getLocation()); d1306 1 a1306 1 Record.AddSourceLocation(E->getLocation()); d1312 1 a1312 1 Record.AddSourceRange(E->getSourceRange()); d1314 1 a1314 1 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo()); d1317 1 a1317 1 Record.AddStmt(E->getExprOperand()); d1324 1 a1324 1 Record.AddSourceLocation(E->getLocation()); d1331 2 a1332 2 Record.AddSourceLocation(E->getThrowLoc()); Record.AddStmt(E->getSubExpr()); d1339 2 a1340 2 Record.AddDeclRef(E->getParam()); Record.AddSourceLocation(E->getUsedLocation()); d1346 2 a1347 2 Record.AddDeclRef(E->getField()); Record.AddSourceLocation(E->getExprLoc()); d1353 2 a1354 2 Record.AddCXXTemporary(E->getTemporary()); Record.AddStmt(E->getSubExpr()); d1360 2 a1361 2 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); Record.AddSourceLocation(E->getRParenLoc()); a1368 1 Record.push_back(E->passAlignment()); d1372 6 a1377 6 Record.AddDeclRef(E->getOperatorNew()); Record.AddDeclRef(E->getOperatorDelete()); Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo()); Record.AddSourceRange(E->getTypeIdParens()); Record.AddSourceRange(E->getSourceRange()); Record.AddSourceRange(E->getDirectInitRange()); d1380 1 a1380 1 Record.AddStmt(*I); d1391 3 a1393 3 Record.AddDeclRef(E->getOperatorDelete()); Record.AddStmt(E->getArgument()); Record.AddSourceLocation(E->getSourceRange().getBegin()); d1401 1 a1401 1 Record.AddStmt(E->getBase()); d1403 5 a1407 5 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); Record.AddTypeSourceInfo(E->getScopeTypeInfo()); Record.AddSourceLocation(E->getColonColonLoc()); Record.AddSourceLocation(E->getTildeLoc()); d1410 1 a1410 1 Record.AddIdentifierRef(E->getDestroyedTypeIdentifier()); d1412 1 a1412 1 Record.AddSourceLocation(E->getDestroyedTypeLoc()); d1414 1 a1414 1 Record.AddTypeSourceInfo(E->getDestroyedTypeInfo()); d1423 3 a1425 4 Record.AddDeclRef(E->getObject(i)); Record.push_back(E->cleanupsHaveSideEffects()); Record.AddStmt(E->getSubExpr()); d1446 1 a1446 1 Record.AddStmt(E->getBase()); d1448 2 a1449 2 Record.AddStmt(nullptr); Record.AddTypeRef(E->getBaseType()); d1451 4 a1454 4 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); Record.AddDeclRef(E->getFirstQualifierFoundInScope()); Record.AddDeclarationNameInfo(E->MemberNameInfo); d1474 2 a1475 2 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); Record.AddDeclarationNameInfo(E->NameInfo); d1485 4 a1488 4 Record.AddStmt(*ArgI); Record.AddTypeSourceInfo(E->getTypeSourceInfo()); Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getRParenLoc()); d1509 1 a1509 1 Record.AddDeclRef(OvI.getDecl()); d1513 2 a1514 2 Record.AddDeclarationNameInfo(E->NameInfo); Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); d1521 3 a1523 3 Record.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr); Record.AddTypeRef(E->getBaseType()); Record.AddSourceLocation(E->getOperatorLoc()); d1531 1 a1531 1 Record.AddDeclRef(E->getNamingClass()); d1540 1 a1540 1 Record.AddSourceRange(E->getSourceRange()); d1542 1 a1542 1 Record.AddTypeSourceInfo(E->getArg(I)); d1550 2 a1551 3 Record.AddSourceRange(E->getSourceRange()); Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo()); Record.AddStmt(E->getDimensionExpression()); d1559 2 a1560 2 Record.AddSourceRange(E->getSourceRange()); Record.AddStmt(E->getQueriedExpression()); d1567 2 a1568 2 Record.AddSourceRange(E->getSourceRange()); Record.AddStmt(E->getOperand()); d1574 1 a1574 1 Record.AddSourceLocation(E->getEllipsisLoc()); d1576 1 a1576 1 Record.AddStmt(E->getPattern()); d1584 4 a1587 4 Record.AddSourceLocation(E->OperatorLoc); Record.AddSourceLocation(E->PackLoc); Record.AddSourceLocation(E->RParenLoc); Record.AddDeclRef(E->Pack); d1590 1 a1590 1 Record.AddTemplateArgument(TA); d1600 3 a1602 3 Record.AddDeclRef(E->getParameter()); Record.AddSourceLocation(E->getNameLoc()); Record.AddStmt(E->getReplacement()); d1609 3 a1611 3 Record.AddDeclRef(E->getParameterPack()); Record.AddTemplateArgument(E->getArgumentPack()); Record.AddSourceLocation(E->getParameterPackLocation()); d1618 2 a1619 2 Record.AddDeclRef(E->getParameterPack()); Record.AddSourceLocation(E->getParameterPackLocation()); d1622 1 a1622 1 Record.AddDeclRef(*I); d1628 2 a1629 2 Record.AddStmt(E->getTemporary()); Record.AddDeclRef(E->getExtendingDecl()); d1636 5 a1640 5 Record.AddSourceLocation(E->LParenLoc); Record.AddSourceLocation(E->EllipsisLoc); Record.AddSourceLocation(E->RParenLoc); Record.AddStmt(E->SubExprs[0]); Record.AddStmt(E->SubExprs[1]); d1647 2 a1648 2 Record.AddStmt(E->getSourceExpr()); Record.AddSourceLocation(E->getLocation()); d1655 1 a1655 1 llvm_unreachable("Cannot write TypoExpr nodes"); d1664 1 a1664 1 Record.AddStmt(E->getConfig()); d1673 3 a1675 3 Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); Record.AddStmt(E->getSrcExpr()); d1685 4 a1688 4 Record.AddStmt(E->getBaseExpr()); Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); Record.AddSourceLocation(E->getMemberLoc()); Record.AddDeclRef(E->getPropertyDecl()); d1694 3 a1696 3 Record.AddStmt(E->getBase()); Record.AddStmt(E->getIdx()); Record.AddSourceLocation(E->getRBracketLoc()); d1702 1 a1702 2 Record.AddSourceRange(E->getSourceRange()); Record.AddString(E->getUuidStr()); d1704 1 a1704 1 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo()); d1707 1 a1707 1 Record.AddStmt(E->getExprOperand()); d1714 3 a1716 3 Record.AddSourceLocation(S->getExceptLoc()); Record.AddStmt(S->getFilterExpr()); Record.AddStmt(S->getBlock()); d1722 2 a1723 2 Record.AddSourceLocation(S->getFinallyLoc()); Record.AddStmt(S->getBlock()); d1730 3 a1732 3 Record.AddSourceLocation(S->getTryLoc()); Record.AddStmt(S->getTryBlock()); Record.AddStmt(S->getHandler()); d1738 1 a1738 1 Record.AddSourceLocation(S->getLeaveLoc()); d1748 2 a1749 1 ASTRecordWriter &Record; d1751 2 a1752 1 OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {} a1756 2 void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C); void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C); d1763 2 a1764 11 Record.AddSourceLocation(C->getLocStart()); Record.AddSourceLocation(C->getLocEnd()); } void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) { Record.AddStmt(C->getPreInitStmt()); } void OMPClauseWriter::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) { VisitOMPClauseWithPreInit(C); Record.AddStmt(C->getPostUpdateExpr()); d1769 4 a1772 4 Record.AddSourceLocation(C->getNameModifierLoc()); Record.AddSourceLocation(C->getColonLoc()); Record.AddStmt(C->getCondition()); Record.AddSourceLocation(C->getLParenLoc()); d1776 2 a1777 2 Record.AddStmt(C->getCondition()); Record.AddSourceLocation(C->getLParenLoc()); d1781 2 a1782 2 Record.AddStmt(C->getNumThreads()); Record.AddSourceLocation(C->getLParenLoc()); d1786 2 a1787 2 Record.AddStmt(C->getSafelen()); Record.AddSourceLocation(C->getLParenLoc()); d1791 2 a1792 2 Record.AddStmt(C->getSimdlen()); Record.AddSourceLocation(C->getLParenLoc()); d1796 2 a1797 2 Record.AddStmt(C->getNumForLoops()); Record.AddSourceLocation(C->getLParenLoc()); d1802 2 a1803 2 Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getDefaultKindKwLoc()); d1808 2 a1809 2 Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getProcBindKindKwLoc()); a1812 1 VisitOMPClauseWithPreInit(C); d1816 7 a1822 6 Record.AddStmt(C->getChunkSize()); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getFirstScheduleModifierLoc()); Record.AddSourceLocation(C->getSecondScheduleModifierLoc()); Record.AddSourceLocation(C->getScheduleKindLoc()); Record.AddSourceLocation(C->getCommaLoc()); d1826 2 a1827 2 Record.AddStmt(C->getNumForLoops()); Record.AddSourceLocation(C->getLParenLoc()); d1854 1 a1854 1 Record.AddSourceLocation(C->getLParenLoc()); d1856 1 a1856 1 Record.AddStmt(VE); d1859 1 a1859 1 Record.AddStmt(VE); d1865 1 a1865 2 VisitOMPClauseWithPreInit(C); Record.AddSourceLocation(C->getLParenLoc()); d1867 1 a1867 1 Record.AddStmt(VE); d1870 1 a1870 1 Record.AddStmt(VE); d1873 1 a1873 1 Record.AddStmt(VE); d1879 1 a1879 2 VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); d1881 1 a1881 1 Record.AddStmt(VE); d1883 1 a1883 1 Record.AddStmt(E); d1885 1 a1885 1 Record.AddStmt(E); d1887 1 a1887 1 Record.AddStmt(E); d1889 1 a1889 1 Record.AddStmt(E); d1894 1 a1894 1 Record.AddSourceLocation(C->getLParenLoc()); d1896 1 a1896 1 Record.AddStmt(VE); d1901 4 a1904 5 VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); Record.AddNestedNameSpecifierLoc(C->getQualifierLoc()); Record.AddDeclarationNameInfo(C->getNameInfo()); d1906 1 a1906 1 Record.AddStmt(VE); d1908 1 a1908 1 Record.AddStmt(VE); d1910 1 a1910 1 Record.AddStmt(E); d1912 1 a1912 1 Record.AddStmt(E); d1914 1 a1914 1 Record.AddStmt(E); d1919 2 a1920 3 VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); d1922 1 a1922 1 Record.AddSourceLocation(C->getModifierLoc()); d1924 1 a1924 1 Record.AddStmt(VE); d1927 1 a1927 1 Record.AddStmt(VE); d1930 1 a1930 1 Record.AddStmt(VE); d1933 1 a1933 1 Record.AddStmt(VE); d1936 1 a1936 1 Record.AddStmt(VE); d1938 2 a1939 2 Record.AddStmt(C->getStep()); Record.AddStmt(C->getCalcStep()); d1944 2 a1945 2 Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); d1947 2 a1948 2 Record.AddStmt(VE); Record.AddStmt(C->getAlignment()); d1953 1 a1953 1 Record.AddSourceLocation(C->getLParenLoc()); d1955 1 a1955 1 Record.AddStmt(VE); d1957 1 a1957 1 Record.AddStmt(E); d1959 1 a1959 1 Record.AddStmt(E); d1961 1 a1961 1 Record.AddStmt(E); d1966 1 a1966 1 Record.AddSourceLocation(C->getLParenLoc()); d1968 1 a1968 1 Record.AddStmt(VE); d1970 1 a1970 1 Record.AddStmt(E); d1972 1 a1972 1 Record.AddStmt(E); d1974 1 a1974 1 Record.AddStmt(E); d1979 1 a1979 1 Record.AddSourceLocation(C->getLParenLoc()); d1981 1 a1981 1 Record.AddStmt(VE); d1986 1 a1986 1 Record.AddSourceLocation(C->getLParenLoc()); d1988 2 a1989 2 Record.AddSourceLocation(C->getDependencyLoc()); Record.AddSourceLocation(C->getColonLoc()); d1991 1 a1991 2 Record.AddStmt(VE); Record.AddStmt(C->getCounterValue()); d1995 2 a1996 2 Record.AddStmt(C->getDevice()); Record.AddSourceLocation(C->getLParenLoc()); d2001 1 a2001 4 Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); d2004 4 a2007 14 Record.AddSourceLocation(C->getMapLoc()); Record.AddSourceLocation(C->getColonLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } d2011 2 a2012 2 Record.AddStmt(C->getNumTeams()); Record.AddSourceLocation(C->getLParenLoc()); d2016 2 a2017 2 Record.AddStmt(C->getThreadLimit()); Record.AddSourceLocation(C->getLParenLoc()); d2021 2 a2022 2 Record.AddStmt(C->getPriority()); Record.AddSourceLocation(C->getLParenLoc()); d2026 2 a2027 2 Record.AddStmt(C->getGrainsize()); Record.AddSourceLocation(C->getLParenLoc()); d2031 2 a2032 2 Record.AddStmt(C->getNumTasks()); Record.AddSourceLocation(C->getLParenLoc()); d2036 2 a2037 103 Record.AddStmt(C->getHint()); Record.AddSourceLocation(C->getLParenLoc()); } void OMPClauseWriter::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) { VisitOMPClauseWithPreInit(C); Record.push_back(C->getDistScheduleKind()); Record.AddStmt(C->getChunkSize()); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getDistScheduleKindLoc()); Record.AddSourceLocation(C->getCommaLoc()); } void OMPClauseWriter::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) { Record.push_back(C->getDefaultmapKind()); Record.push_back(C->getDefaultmapModifier()); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getDefaultmapModifierLoc()); Record.AddSourceLocation(C->getDefaultmapKindLoc()); } void OMPClauseWriter::VisitOMPToClause(OMPToClause *C) { Record.push_back(C->varlist_size()); Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } } void OMPClauseWriter::VisitOMPFromClause(OMPFromClause *C) { Record.push_back(C->varlist_size()); Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } } void OMPClauseWriter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) { Record.push_back(C->varlist_size()); Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *VE : C->private_copies()) Record.AddStmt(VE); for (auto *VE : C->inits()) Record.AddStmt(VE); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } } void OMPClauseWriter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) { Record.push_back(C->varlist_size()); Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } d2044 3 a2046 3 Record.AddSourceLocation(E->getLocStart()); Record.AddSourceLocation(E->getLocEnd()); OMPClauseWriter ClauseWriter(Record); d2051 1 a2051 1 Record.AddStmt(E->getAssociatedStmt()); d2059 15 a2073 23 Record.AddStmt(D->getIterationVariable()); Record.AddStmt(D->getLastIteration()); Record.AddStmt(D->getCalcLastIteration()); Record.AddStmt(D->getPreCond()); Record.AddStmt(D->getCond()); Record.AddStmt(D->getInit()); Record.AddStmt(D->getInc()); Record.AddStmt(D->getPreInits()); if (isOpenMPWorksharingDirective(D->getDirectiveKind()) || isOpenMPTaskLoopDirective(D->getDirectiveKind()) || isOpenMPDistributeDirective(D->getDirectiveKind())) { Record.AddStmt(D->getIsLastIterVariable()); Record.AddStmt(D->getLowerBoundVariable()); Record.AddStmt(D->getUpperBoundVariable()); Record.AddStmt(D->getStrideVariable()); Record.AddStmt(D->getEnsureUpperBound()); Record.AddStmt(D->getNextLowerBound()); Record.AddStmt(D->getNextUpperBound()); Record.AddStmt(D->getNumIterations()); } if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) { Record.AddStmt(D->getPrevLowerBoundVariable()); Record.AddStmt(D->getPrevUpperBoundVariable()); d2076 1 a2076 1 Record.AddStmt(I); d2079 1 a2079 1 Record.AddStmt(I); d2082 1 a2082 1 Record.AddStmt(I); d2085 1 a2085 1 Record.AddStmt(I); d2088 1 a2088 1 Record.AddStmt(I); d2148 1 a2148 1 Record.AddDeclarationNameInfo(D->getDirectiveName()); d2185 4 a2188 4 Record.AddStmt(D->getX()); Record.AddStmt(D->getV()); Record.AddStmt(D->getExpr()); Record.AddStmt(D->getUpdateExpr()); a2207 31 void ASTStmtWriter::VisitOMPTargetEnterDataDirective( OMPTargetEnterDataDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetExitDataDirective( OMPTargetExitDataDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetParallelDirective( OMPTargetParallelDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetParallelForDirective( OMPTargetParallelForDirective *D) { VisitOMPLoopDirective(D); Record.push_back(D->hasCancel() ? 1 : 0); Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE; } a2283 92 void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE; } void ASTStmtWriter::VisitOMPDistributeParallelForDirective( OMPDistributeParallelForDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective( OMPDistributeParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPDistributeSimdDirective( OMPDistributeSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective( OMPTargetParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTeamsDistributeDirective( OMPTeamsDistributeDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE; } void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective( OMPTeamsDistributeSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective( OMPTeamsDistributeParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective( OMPTeamsDistributeParallelForDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective( OMPTargetTeamsDistributeDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective( OMPTargetTeamsDistributeParallelForDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective( OMPTargetTeamsDistributeParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization:: STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective( OMPTargetTeamsDistributeSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE; } d2308 3 a2310 1 void ASTWriter::WriteSubStmt(Stmt *S) { d2346 6 d2354 22 a2375 2 uint64_t Offset = Writer.Emit(); SubStmtEntries[S] = Offset; d2380 3 a2382 1 void ASTRecordWriter::FlushStmts() { d2385 2 a2386 2 assert(Writer->SubStmtEntries.empty() && "unexpected entries in sub-stmt map"); assert(Writer->ParentStmts.empty() && "unexpected entries in parent stmt map"); d2389 1 a2389 1 Writer->WriteSubStmt(StmtsToEmit[I]); d2391 2 a2392 1 assert(N == StmtsToEmit.size() && "record modified while being written!"); d2397 1 a2397 5 Writer->Stream.EmitRecord(serialization::STMT_STOP, ArrayRef()); Writer->SubStmtEntries.clear(); Writer->ParentStmts.clear(); } d2399 2 a2400 10 StmtsToEmit.clear(); } void ASTRecordWriter::FlushSubStmts() { // For a nested statement, write out the substatements in reverse order (so // that a simple stack machine can be used when loading), and don't emit a // STMT_STOP after each one. for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { Writer->WriteSubStmt(StmtsToEmit[N - I - 1]); assert(N == StmtsToEmit.size() && "record modified while being written!"); @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @d32 1 d34 1 a34 1 ASTRecordWriter Record; d36 1 a39 1 public: d41 1 a41 10 : Writer(Writer), Record(Writer, Record), Code(serialization::STMT_NULL_PTR), AbbrevToUse(0) {} ASTStmtWriter(const ASTStmtWriter&) = delete; uint64_t Emit() { assert(Code != serialization::STMT_NULL_PTR && "unhandled sub-statement writing AST file"); return Record.EmitStmt(Code, AbbrevToUse); } d55 3 a57 3 Record.AddSourceLocation(ArgInfo.TemplateKWLoc); Record.AddSourceLocation(ArgInfo.LAngleLoc); Record.AddSourceLocation(ArgInfo.RAngleLoc); d59 1 a59 1 Record.AddTemplateArgumentLoc(Args[i]); d67 1 a67 1 Record.AddSourceLocation(S->getSemiLoc()); d76 3 a78 3 Record.AddStmt(CS); Record.AddSourceLocation(S->getLBracLoc()); Record.AddSourceLocation(S->getRBracLoc()); d85 2 a86 2 Record.AddSourceLocation(S->getKeywordLoc()); Record.AddSourceLocation(S->getColonLoc()); d91 4 a94 4 Record.AddStmt(S->getLHS()); Record.AddStmt(S->getRHS()); Record.AddStmt(S->getSubStmt()); Record.AddSourceLocation(S->getEllipsisLoc()); d100 1 a100 1 Record.AddStmt(S->getSubStmt()); d106 3 a108 3 Record.AddDeclRef(S->getDecl()); Record.AddStmt(S->getSubStmt()); Record.AddSourceLocation(S->getIdentLoc()); d115 3 a117 3 Record.AddAttributes(S->getAttrs()); Record.AddStmt(S->getSubStmt()); Record.AddSourceLocation(S->getAttrLoc()); d123 6 a128 8 Record.push_back(S->isConstexpr()); Record.AddStmt(S->getInit()); Record.AddDeclRef(S->getConditionVariable()); Record.AddStmt(S->getCond()); Record.AddStmt(S->getThen()); Record.AddStmt(S->getElse()); Record.AddSourceLocation(S->getIfLoc()); Record.AddSourceLocation(S->getElseLoc()); d134 4 a137 5 Record.AddStmt(S->getInit()); Record.AddDeclRef(S->getConditionVariable()); Record.AddStmt(S->getCond()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getSwitchLoc()); d147 4 a150 4 Record.AddDeclRef(S->getConditionVariable()); Record.AddStmt(S->getCond()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getWhileLoc()); d156 5 a160 5 Record.AddStmt(S->getCond()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getDoLoc()); Record.AddSourceLocation(S->getWhileLoc()); Record.AddSourceLocation(S->getRParenLoc()); d166 8 a173 8 Record.AddStmt(S->getInit()); Record.AddStmt(S->getCond()); Record.AddDeclRef(S->getConditionVariable()); Record.AddStmt(S->getInc()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getForLoc()); Record.AddSourceLocation(S->getLParenLoc()); Record.AddSourceLocation(S->getRParenLoc()); d179 3 a181 3 Record.AddDeclRef(S->getLabel()); Record.AddSourceLocation(S->getGotoLoc()); Record.AddSourceLocation(S->getLabelLoc()); d187 3 a189 3 Record.AddSourceLocation(S->getGotoLoc()); Record.AddSourceLocation(S->getStarLoc()); Record.AddStmt(S->getTarget()); d195 1 a195 1 Record.AddSourceLocation(S->getContinueLoc()); d201 1 a201 1 Record.AddSourceLocation(S->getBreakLoc()); d207 3 a209 3 Record.AddStmt(S->getRetValue()); Record.AddSourceLocation(S->getReturnLoc()); Record.AddDeclRef(S->getNRVOCandidate()); d215 2 a216 2 Record.AddSourceLocation(S->getStartLoc()); Record.AddSourceLocation(S->getEndLoc()); d219 1 a219 1 Record.AddDeclRef(*D); d228 1 a228 1 Record.AddSourceLocation(S->getAsmLoc()); d235 2 a236 2 Record.AddSourceLocation(S->getRParenLoc()); Record.AddStmt(S->getAsmString()); d240 3 a242 3 Record.AddIdentifierRef(S->getOutputIdentifier(I)); Record.AddStmt(S->getOutputConstraintLiteral(I)); Record.AddStmt(S->getOutputExpr(I)); d247 3 a249 3 Record.AddIdentifierRef(S->getInputIdentifier(I)); Record.AddStmt(S->getInputConstraintLiteral(I)); Record.AddStmt(S->getInputExpr(I)); d254 1 a254 1 Record.AddStmt(S->getClobberStringLiteral(I)); d261 2 a262 2 Record.AddSourceLocation(S->getLBraceLoc()); Record.AddSourceLocation(S->getEndLoc()); d264 1 a264 1 Record.AddString(S->getAsmString()); d268 1 a268 2 // FIXME: Move this to ASTRecordWriter? Writer.AddToken(S->getAsmToks()[I], Record.getRecordData()); d273 1 a273 1 Record.AddString(S->getClobber(I)); d278 2 a279 2 Record.AddStmt(S->getOutputExpr(I)); Record.AddString(S->getOutputConstraint(I)); d284 2 a285 2 Record.AddStmt(S->getInputExpr(I)); Record.AddString(S->getInputConstraint(I)); d317 1 a317 1 Record.AddDeclRef(S->getCapturedDecl()); d320 1 a320 1 Record.AddDeclRef(S->getCapturedRecordDecl()); d324 1 a324 1 Record.AddStmt(I); d327 1 a327 1 Record.AddStmt(S->getCapturedStmt()); d332 1 a332 1 Record.AddDeclRef(nullptr); d334 1 a334 1 Record.AddDeclRef(I.getCapturedVar()); d336 1 a336 1 Record.AddSourceLocation(I.getLocation()); d344 1 a344 1 Record.AddTypeRef(E->getType()); d355 1 a355 1 Record.AddSourceLocation(E->getLocation()); d357 1 a357 1 Record.AddStmt(E->getFunctionName()); d384 1 a384 1 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); d387 1 a387 1 Record.AddDeclRef(E->getFoundDecl()); d393 3 a395 3 Record.AddDeclRef(E->getDecl()); Record.AddSourceLocation(E->getLocation()); Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName()); d401 2 a402 2 Record.AddSourceLocation(E->getLocation()); Record.AddAPInt(E->getValue()); d415 2 a416 2 Record.AddAPFloat(E->getValue()); Record.AddSourceLocation(E->getLocation()); d422 1 a422 1 Record.AddStmt(E->getSubExpr()); d438 1 a438 1 Record.AddSourceLocation(E->getStrTokenLoc(I)); d445 1 a445 1 Record.AddSourceLocation(E->getLocation()); d455 3 a457 3 Record.AddSourceLocation(E->getLParen()); Record.AddSourceLocation(E->getRParen()); Record.AddStmt(E->getSubExpr()); d465 3 a467 3 Record.AddStmt(E->Exprs[i]); Record.AddSourceLocation(E->LParenLoc); Record.AddSourceLocation(E->RParenLoc); d473 1 a473 1 Record.AddStmt(E->getSubExpr()); d475 1 a475 1 Record.AddSourceLocation(E->getOperatorLoc()); d483 3 a485 3 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddSourceLocation(E->getRParenLoc()); Record.AddTypeSourceInfo(E->getTypeSourceInfo()); d489 2 a490 2 Record.AddSourceLocation(ON.getSourceRange().getBegin()); Record.AddSourceLocation(ON.getSourceRange().getEnd()); d497 1 a497 1 Record.AddDeclRef(ON.getField()); d501 1 a501 1 Record.AddIdentifierRef(ON.getFieldName()); d505 1 a505 1 Record.AddCXXBaseSpecifier(*ON.getBase()); d510 1 a510 1 Record.AddStmt(E->getIndexExpr(I)); d518 1 a518 1 Record.AddTypeSourceInfo(E->getArgumentTypeInfo()); d521 1 a521 1 Record.AddStmt(E->getArgumentExpr()); d523 2 a524 2 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddSourceLocation(E->getRParenLoc()); d530 3 a532 3 Record.AddStmt(E->getLHS()); Record.AddStmt(E->getRHS()); Record.AddSourceLocation(E->getRBracketLoc()); d538 5 a542 5 Record.AddStmt(E->getBase()); Record.AddStmt(E->getLowerBound()); Record.AddStmt(E->getLength()); Record.AddSourceLocation(E->getColonLoc()); Record.AddSourceLocation(E->getRBracketLoc()); d549 2 a550 2 Record.AddSourceLocation(E->getRParenLoc()); Record.AddStmt(E->getCallee()); d553 1 a553 1 Record.AddStmt(*Arg); d562 1 a562 1 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); d566 1 a566 1 Record.AddSourceLocation(E->getTemplateKeywordLoc()); d569 2 a570 2 Record.AddSourceLocation(E->getLAngleLoc()); Record.AddSourceLocation(E->getRAngleLoc()); d572 1 a572 1 Record.AddTemplateArgumentLoc(E->getTemplateArgs()[i]); d578 1 a578 1 Record.AddDeclRef(FoundDecl.getDecl()); d581 1 a581 1 Record.AddTypeRef(E->getType()); d584 3 a586 3 Record.AddStmt(E->getBase()); Record.AddDeclRef(E->getMemberDecl()); Record.AddSourceLocation(E->getMemberLoc()); d588 3 a590 3 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddDeclarationNameLoc(E->MemberDNLoc, E->getMemberDecl()->getDeclName()); d596 3 a598 3 Record.AddStmt(E->getBase()); Record.AddSourceLocation(E->getIsaMemberLoc()); Record.AddSourceLocation(E->getOpLoc()); d606 1 a606 1 Record.AddStmt(E->getSubExpr()); d613 2 a614 2 Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getBridgeKeywordLoc()); d622 1 a622 1 Record.AddStmt(E->getSubExpr()); d627 1 a627 1 Record.AddCXXBaseSpecifier(**PI); d632 2 a633 2 Record.AddStmt(E->getLHS()); Record.AddStmt(E->getRHS()); d635 1 a635 1 Record.AddSourceLocation(E->getOperatorLoc()); d642 2 a643 2 Record.AddTypeRef(E->getComputationLHSType()); Record.AddTypeRef(E->getComputationResultType()); d649 5 a653 5 Record.AddStmt(E->getCond()); Record.AddStmt(E->getLHS()); Record.AddStmt(E->getRHS()); Record.AddSourceLocation(E->getQuestionLoc()); Record.AddSourceLocation(E->getColonLoc()); d660 7 a666 7 Record.AddStmt(E->getOpaqueValue()); Record.AddStmt(E->getCommon()); Record.AddStmt(E->getCond()); Record.AddStmt(E->getTrueExpr()); Record.AddStmt(E->getFalseExpr()); Record.AddSourceLocation(E->getQuestionLoc()); Record.AddSourceLocation(E->getColonLoc()); d681 1 a681 1 Record.AddTypeSourceInfo(E->getTypeInfoAsWritten()); d686 2 a687 2 Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getRParenLoc()); d693 3 a695 3 Record.AddSourceLocation(E->getLParenLoc()); Record.AddTypeSourceInfo(E->getTypeSourceInfo()); Record.AddStmt(E->getInitializer()); d702 3 a704 3 Record.AddStmt(E->getBase()); Record.AddIdentifierRef(&E->getAccessor()); Record.AddSourceLocation(E->getAccessorLoc()); d712 3 a714 3 Record.AddStmt(E->getSyntacticForm()); Record.AddSourceLocation(E->getLBraceLoc()); Record.AddSourceLocation(E->getRBraceLoc()); d718 1 a718 1 Record.AddStmt(E->getArrayFiller()); d720 1 a720 1 Record.AddDeclRef(E->getInitializedFieldInUnion()); d728 1 a728 1 Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr); d731 1 a731 1 Record.AddStmt(E->getInit(I)); d740 2 a741 2 Record.AddStmt(E->getSubExpr(I)); Record.AddSourceLocation(E->getEqualOrColonLoc()); d743 5 a747 3 for (const DesignatedInitExpr::Designator &D : E->designators()) { if (D.isFieldDesignator()) { if (FieldDecl *Field = D.getField()) { d749 1 a749 1 Record.AddDeclRef(Field); d752 1 a752 1 Record.AddIdentifierRef(D.getFieldName()); d754 3 a756 3 Record.AddSourceLocation(D.getDotLoc()); Record.AddSourceLocation(D.getFieldLoc()); } else if (D.isArrayDesignator()) { d758 3 a760 3 Record.push_back(D.getFirstExprIndex()); Record.AddSourceLocation(D.getLBracketLoc()); Record.AddSourceLocation(D.getRBracketLoc()); d762 1 a762 1 assert(D.isArrayRangeDesignator() && "Unknown designator"); d764 4 a767 4 Record.push_back(D.getFirstExprIndex()); Record.AddSourceLocation(D.getLBracketLoc()); Record.AddSourceLocation(D.getEllipsisLoc()); Record.AddSourceLocation(D.getRBracketLoc()); d775 2 a776 2 Record.AddStmt(E->getBase()); Record.AddStmt(E->getUpdater()); a784 12 void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { VisitExpr(E); Record.AddStmt(E->SubExprs[0]); Record.AddStmt(E->SubExprs[1]); Code = serialization::EXPR_ARRAY_INIT_LOOP; } void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { VisitExpr(E); Code = serialization::EXPR_ARRAY_INIT_INDEX; } d792 4 a795 4 Record.AddStmt(E->getSubExpr()); Record.AddTypeSourceInfo(E->getWrittenTypeInfo()); Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); d802 3 a804 3 Record.AddSourceLocation(E->getAmpAmpLoc()); Record.AddSourceLocation(E->getLabelLoc()); Record.AddDeclRef(E->getLabel()); d810 3 a812 3 Record.AddStmt(E->getSubStmt()); Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getRParenLoc()); d818 5 a822 5 Record.AddStmt(E->getCond()); Record.AddStmt(E->getLHS()); Record.AddStmt(E->getRHS()); Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); d829 1 a829 1 Record.AddSourceLocation(E->getTokenLocation()); d837 3 a839 3 Record.AddStmt(E->getExpr(I)); Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); d845 4 a848 4 Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); Record.AddTypeSourceInfo(E->getTypeSourceInfo()); Record.AddStmt(E->getSrcExpr()); d854 1 a854 1 Record.AddDeclRef(E->getBlockDecl()); d862 1 a862 1 Record.AddStmt(E->getControllingExpr()); d864 2 a865 2 Record.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I)); Record.AddStmt(E->getAssocExpr(I)); d869 3 a871 3 Record.AddSourceLocation(E->getGenericLoc()); Record.AddSourceLocation(E->getDefaultLoc()); Record.AddSourceLocation(E->getRParenLoc()); d885 1 a885 1 Record.AddStmt(E->getSyntacticForm()); d888 1 a888 1 Record.AddStmt(*i); d897 3 a899 3 Record.AddStmt(E->getSubExprs()[I]); Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); d909 2 a910 2 Record.AddStmt(E->getString()); Record.AddSourceLocation(E->getAtLoc()); d916 3 a918 3 Record.AddStmt(E->getSubExpr()); Record.AddDeclRef(E->getBoxingMethod()); Record.AddSourceRange(E->getSourceRange()); d926 3 a928 3 Record.AddStmt(E->getElement(i)); Record.AddDeclRef(E->getArrayWithObjectsMethod()); Record.AddSourceRange(E->getSourceRange()); d938 2 a939 2 Record.AddStmt(Element.Key); Record.AddStmt(Element.Value); d941 1 a941 1 Record.AddSourceLocation(Element.EllipsisLoc); d949 2 a950 2 Record.AddDeclRef(E->getDictWithObjectsMethod()); Record.AddSourceRange(E->getSourceRange()); d956 3 a958 3 Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo()); Record.AddSourceLocation(E->getAtLoc()); Record.AddSourceLocation(E->getRParenLoc()); d964 3 a966 3 Record.AddSelectorRef(E->getSelector()); Record.AddSourceLocation(E->getAtLoc()); Record.AddSourceLocation(E->getRParenLoc()); d972 4 a975 4 Record.AddDeclRef(E->getProtocol()); Record.AddSourceLocation(E->getAtLoc()); Record.AddSourceLocation(E->ProtoLoc); Record.AddSourceLocation(E->getRParenLoc()); d981 4 a984 4 Record.AddDeclRef(E->getDecl()); Record.AddSourceLocation(E->getLocation()); Record.AddSourceLocation(E->getOpLoc()); Record.AddStmt(E->getBase()); d995 2 a996 2 Record.AddDeclRef(E->getImplicitPropertyGetter()); Record.AddDeclRef(E->getImplicitPropertySetter()); d998 1 a998 1 Record.AddDeclRef(E->getExplicitProperty()); d1000 2 a1001 2 Record.AddSourceLocation(E->getLocation()); Record.AddSourceLocation(E->getReceiverLocation()); d1004 1 a1004 1 Record.AddStmt(E->getBase()); d1007 1 a1007 1 Record.AddTypeRef(E->getSuperReceiverType()); d1010 1 a1010 1 Record.AddDeclRef(E->getClassReceiver()); d1018 5 a1022 5 Record.AddSourceLocation(E->getRBracket()); Record.AddStmt(E->getBaseExpr()); Record.AddStmt(E->getKeyExpr()); Record.AddDeclRef(E->getAtIndexMethodDecl()); Record.AddDeclRef(E->setAtIndexMethodDecl()); d1037 1 a1037 1 Record.AddStmt(E->getInstanceReceiver()); d1041 1 a1041 1 Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo()); d1046 2 a1047 2 Record.AddTypeRef(E->getSuperType()); Record.AddSourceLocation(E->getSuperLoc()); d1053 1 a1053 1 Record.AddDeclRef(E->getMethodDecl()); d1056 1 a1056 1 Record.AddSelectorRef(E->getSelector()); d1059 2 a1060 2 Record.AddSourceLocation(E->getLeftLoc()); Record.AddSourceLocation(E->getRightLoc()); d1064 1 a1064 1 Record.AddStmt(*Arg); d1068 1 a1068 1 Record.AddSourceLocation(Locs[i]); d1075 5 a1079 5 Record.AddStmt(S->getElement()); Record.AddStmt(S->getCollection()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getForLoc()); Record.AddSourceLocation(S->getRParenLoc()); d1084 4 a1087 4 Record.AddStmt(S->getCatchBody()); Record.AddDeclRef(S->getCatchParamDecl()); Record.AddSourceLocation(S->getAtCatchLoc()); Record.AddSourceLocation(S->getRParenLoc()); d1092 2 a1093 2 Record.AddStmt(S->getFinallyBody()); Record.AddSourceLocation(S->getAtFinallyLoc()); d1098 2 a1099 2 Record.AddStmt(S->getSubStmt()); Record.AddSourceLocation(S->getAtLoc()); d1106 1 a1106 1 Record.AddStmt(S->getTryBody()); d1108 1 a1108 1 Record.AddStmt(S->getCatchStmt(I)); d1110 2 a1111 2 Record.AddStmt(S->getFinallyStmt()); Record.AddSourceLocation(S->getAtTryLoc()); d1116 3 a1118 3 Record.AddStmt(S->getSynchExpr()); Record.AddStmt(S->getSynchBody()); Record.AddSourceLocation(S->getAtSynchronizedLoc()); d1123 2 a1124 2 Record.AddStmt(S->getThrowExpr()); Record.AddSourceLocation(S->getThrowLoc()); d1131 1 a1131 1 Record.AddSourceLocation(E->getLocation()); a1134 7 void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) { VisitExpr(E); Record.AddSourceRange(E->getSourceRange()); Record.AddVersionTuple(E->getVersion()); Code = serialization::EXPR_OBJC_AVAILABILITY_CHECK; } d1141 3 a1143 3 Record.AddSourceLocation(S->getCatchLoc()); Record.AddDeclRef(S->getExceptionDecl()); Record.AddStmt(S->getHandlerBlock()); d1150 2 a1151 2 Record.AddSourceLocation(S->getTryLoc()); Record.AddStmt(S->getTryBlock()); d1153 1 a1153 1 Record.AddStmt(S->getHandler(i)); d1159 10 a1168 11 Record.AddSourceLocation(S->getForLoc()); Record.AddSourceLocation(S->getCoawaitLoc()); Record.AddSourceLocation(S->getColonLoc()); Record.AddSourceLocation(S->getRParenLoc()); Record.AddStmt(S->getRangeStmt()); Record.AddStmt(S->getBeginStmt()); Record.AddStmt(S->getEndStmt()); Record.AddStmt(S->getCond()); Record.AddStmt(S->getInc()); Record.AddStmt(S->getLoopVarStmt()); Record.AddStmt(S->getBody()); d1174 1 a1174 1 Record.AddSourceLocation(S->getKeywordLoc()); d1176 3 a1178 3 Record.AddNestedNameSpecifierLoc(S->getQualifierLoc()); Record.AddDeclarationNameInfo(S->getNameInfo()); Record.AddStmt(S->getSubStmt()); d1185 1 a1185 1 Record.AddSourceRange(E->Range); d1199 3 a1201 3 Record.AddStmt(E->getArg(I)); Record.AddDeclRef(E->getConstructor()); Record.AddSourceLocation(E->getLocation()); d1208 1 a1208 1 Record.AddSourceRange(E->getParenOrBraceRange()); a1211 9 void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { VisitExpr(E); Record.AddDeclRef(E->getConstructor()); Record.AddSourceLocation(E->getLocation()); Record.push_back(E->constructsVBase()); Record.push_back(E->inheritedFromVBase()); Code = serialization::EXPR_CXX_INHERITED_CTOR_INIT; } d1214 1 a1214 1 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); d1221 5 a1225 1 Record.AddSourceRange(E->IntroducerRange); d1227 1 a1227 1 Record.AddSourceLocation(E->CaptureDefaultLoc); d1230 1 a1230 1 Record.AddSourceLocation(E->ClosingBrace); d1236 10 a1245 1 Record.AddStmt(*C); d1253 1 a1253 1 Record.AddStmt(E->getSubExpr()); d1259 3 a1261 2 Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc())); Record.AddSourceRange(E->getAngleBrackets()); d1286 2 a1287 2 Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getRParenLoc()); d1293 1 a1293 1 Record.AddSourceLocation(E->UDSuffixLoc); d1300 1 a1300 1 Record.AddSourceLocation(E->getLocation()); d1306 1 a1306 1 Record.AddSourceLocation(E->getLocation()); d1312 1 a1312 1 Record.AddSourceRange(E->getSourceRange()); d1314 1 a1314 1 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo()); d1317 1 a1317 1 Record.AddStmt(E->getExprOperand()); d1324 1 a1324 1 Record.AddSourceLocation(E->getLocation()); d1331 2 a1332 2 Record.AddSourceLocation(E->getThrowLoc()); Record.AddStmt(E->getSubExpr()); d1339 2 a1340 2 Record.AddDeclRef(E->getParam()); Record.AddSourceLocation(E->getUsedLocation()); d1346 2 a1347 2 Record.AddDeclRef(E->getField()); Record.AddSourceLocation(E->getExprLoc()); d1353 2 a1354 2 Record.AddCXXTemporary(E->getTemporary()); Record.AddStmt(E->getSubExpr()); d1360 2 a1361 2 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); Record.AddSourceLocation(E->getRParenLoc()); a1368 1 Record.push_back(E->passAlignment()); d1372 6 a1377 6 Record.AddDeclRef(E->getOperatorNew()); Record.AddDeclRef(E->getOperatorDelete()); Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo()); Record.AddSourceRange(E->getTypeIdParens()); Record.AddSourceRange(E->getSourceRange()); Record.AddSourceRange(E->getDirectInitRange()); d1380 1 a1380 1 Record.AddStmt(*I); d1391 3 a1393 3 Record.AddDeclRef(E->getOperatorDelete()); Record.AddStmt(E->getArgument()); Record.AddSourceLocation(E->getSourceRange().getBegin()); d1401 1 a1401 1 Record.AddStmt(E->getBase()); d1403 5 a1407 5 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); Record.AddTypeSourceInfo(E->getScopeTypeInfo()); Record.AddSourceLocation(E->getColonColonLoc()); Record.AddSourceLocation(E->getTildeLoc()); d1410 1 a1410 1 Record.AddIdentifierRef(E->getDestroyedTypeIdentifier()); d1412 1 a1412 1 Record.AddSourceLocation(E->getDestroyedTypeLoc()); d1414 1 a1414 1 Record.AddTypeSourceInfo(E->getDestroyedTypeInfo()); d1423 3 a1425 4 Record.AddDeclRef(E->getObject(i)); Record.push_back(E->cleanupsHaveSideEffects()); Record.AddStmt(E->getSubExpr()); d1446 1 a1446 1 Record.AddStmt(E->getBase()); d1448 2 a1449 2 Record.AddStmt(nullptr); Record.AddTypeRef(E->getBaseType()); d1451 4 a1454 4 Record.AddSourceLocation(E->getOperatorLoc()); Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); Record.AddDeclRef(E->getFirstQualifierFoundInScope()); Record.AddDeclarationNameInfo(E->MemberNameInfo); d1474 2 a1475 2 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); Record.AddDeclarationNameInfo(E->NameInfo); d1485 4 a1488 4 Record.AddStmt(*ArgI); Record.AddTypeSourceInfo(E->getTypeSourceInfo()); Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getRParenLoc()); d1509 1 a1509 1 Record.AddDeclRef(OvI.getDecl()); d1513 2 a1514 2 Record.AddDeclarationNameInfo(E->NameInfo); Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); d1521 3 a1523 3 Record.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr); Record.AddTypeRef(E->getBaseType()); Record.AddSourceLocation(E->getOperatorLoc()); d1531 1 a1531 1 Record.AddDeclRef(E->getNamingClass()); d1540 1 a1540 1 Record.AddSourceRange(E->getSourceRange()); d1542 1 a1542 1 Record.AddTypeSourceInfo(E->getArg(I)); d1550 2 a1551 3 Record.AddSourceRange(E->getSourceRange()); Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo()); Record.AddStmt(E->getDimensionExpression()); d1559 2 a1560 2 Record.AddSourceRange(E->getSourceRange()); Record.AddStmt(E->getQueriedExpression()); d1567 2 a1568 2 Record.AddSourceRange(E->getSourceRange()); Record.AddStmt(E->getOperand()); d1574 1 a1574 1 Record.AddSourceLocation(E->getEllipsisLoc()); d1576 1 a1576 1 Record.AddStmt(E->getPattern()); d1584 4 a1587 4 Record.AddSourceLocation(E->OperatorLoc); Record.AddSourceLocation(E->PackLoc); Record.AddSourceLocation(E->RParenLoc); Record.AddDeclRef(E->Pack); d1590 1 a1590 1 Record.AddTemplateArgument(TA); d1600 3 a1602 3 Record.AddDeclRef(E->getParameter()); Record.AddSourceLocation(E->getNameLoc()); Record.AddStmt(E->getReplacement()); d1609 3 a1611 3 Record.AddDeclRef(E->getParameterPack()); Record.AddTemplateArgument(E->getArgumentPack()); Record.AddSourceLocation(E->getParameterPackLocation()); d1618 2 a1619 2 Record.AddDeclRef(E->getParameterPack()); Record.AddSourceLocation(E->getParameterPackLocation()); d1622 1 a1622 1 Record.AddDeclRef(*I); d1628 2 a1629 2 Record.AddStmt(E->getTemporary()); Record.AddDeclRef(E->getExtendingDecl()); d1636 5 a1640 5 Record.AddSourceLocation(E->LParenLoc); Record.AddSourceLocation(E->EllipsisLoc); Record.AddSourceLocation(E->RParenLoc); Record.AddStmt(E->SubExprs[0]); Record.AddStmt(E->SubExprs[1]); d1647 2 a1648 2 Record.AddStmt(E->getSourceExpr()); Record.AddSourceLocation(E->getLocation()); d1655 1 a1655 1 llvm_unreachable("Cannot write TypoExpr nodes"); d1664 1 a1664 1 Record.AddStmt(E->getConfig()); d1673 3 a1675 3 Record.AddSourceLocation(E->getBuiltinLoc()); Record.AddSourceLocation(E->getRParenLoc()); Record.AddStmt(E->getSrcExpr()); d1685 4 a1688 4 Record.AddStmt(E->getBaseExpr()); Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); Record.AddSourceLocation(E->getMemberLoc()); Record.AddDeclRef(E->getPropertyDecl()); d1694 3 a1696 3 Record.AddStmt(E->getBase()); Record.AddStmt(E->getIdx()); Record.AddSourceLocation(E->getRBracketLoc()); d1702 1 a1702 2 Record.AddSourceRange(E->getSourceRange()); Record.AddString(E->getUuidStr()); d1704 1 a1704 1 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo()); d1707 1 a1707 1 Record.AddStmt(E->getExprOperand()); d1714 3 a1716 3 Record.AddSourceLocation(S->getExceptLoc()); Record.AddStmt(S->getFilterExpr()); Record.AddStmt(S->getBlock()); d1722 2 a1723 2 Record.AddSourceLocation(S->getFinallyLoc()); Record.AddStmt(S->getBlock()); d1730 3 a1732 3 Record.AddSourceLocation(S->getTryLoc()); Record.AddStmt(S->getTryBlock()); Record.AddStmt(S->getHandler()); d1738 1 a1738 1 Record.AddSourceLocation(S->getLeaveLoc()); d1748 2 a1749 1 ASTRecordWriter &Record; d1751 2 a1752 1 OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {} a1756 2 void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C); void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C); d1763 2 a1764 11 Record.AddSourceLocation(C->getLocStart()); Record.AddSourceLocation(C->getLocEnd()); } void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) { Record.AddStmt(C->getPreInitStmt()); } void OMPClauseWriter::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) { VisitOMPClauseWithPreInit(C); Record.AddStmt(C->getPostUpdateExpr()); d1769 4 a1772 4 Record.AddSourceLocation(C->getNameModifierLoc()); Record.AddSourceLocation(C->getColonLoc()); Record.AddStmt(C->getCondition()); Record.AddSourceLocation(C->getLParenLoc()); d1776 2 a1777 2 Record.AddStmt(C->getCondition()); Record.AddSourceLocation(C->getLParenLoc()); d1781 2 a1782 2 Record.AddStmt(C->getNumThreads()); Record.AddSourceLocation(C->getLParenLoc()); d1786 2 a1787 2 Record.AddStmt(C->getSafelen()); Record.AddSourceLocation(C->getLParenLoc()); d1791 2 a1792 2 Record.AddStmt(C->getSimdlen()); Record.AddSourceLocation(C->getLParenLoc()); d1796 2 a1797 2 Record.AddStmt(C->getNumForLoops()); Record.AddSourceLocation(C->getLParenLoc()); d1802 2 a1803 2 Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getDefaultKindKwLoc()); d1808 2 a1809 2 Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getProcBindKindKwLoc()); a1812 1 VisitOMPClauseWithPreInit(C); d1816 7 a1822 6 Record.AddStmt(C->getChunkSize()); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getFirstScheduleModifierLoc()); Record.AddSourceLocation(C->getSecondScheduleModifierLoc()); Record.AddSourceLocation(C->getScheduleKindLoc()); Record.AddSourceLocation(C->getCommaLoc()); d1826 2 a1827 2 Record.AddStmt(C->getNumForLoops()); Record.AddSourceLocation(C->getLParenLoc()); d1854 1 a1854 1 Record.AddSourceLocation(C->getLParenLoc()); d1856 1 a1856 1 Record.AddStmt(VE); d1859 1 a1859 1 Record.AddStmt(VE); d1865 1 a1865 2 VisitOMPClauseWithPreInit(C); Record.AddSourceLocation(C->getLParenLoc()); d1867 1 a1867 1 Record.AddStmt(VE); d1870 1 a1870 1 Record.AddStmt(VE); d1873 1 a1873 1 Record.AddStmt(VE); d1879 1 a1879 2 VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); d1881 1 a1881 1 Record.AddStmt(VE); d1883 1 a1883 1 Record.AddStmt(E); d1885 1 a1885 1 Record.AddStmt(E); d1887 1 a1887 1 Record.AddStmt(E); d1889 1 a1889 1 Record.AddStmt(E); d1894 1 a1894 1 Record.AddSourceLocation(C->getLParenLoc()); d1896 1 a1896 1 Record.AddStmt(VE); d1901 4 a1904 5 VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); Record.AddNestedNameSpecifierLoc(C->getQualifierLoc()); Record.AddDeclarationNameInfo(C->getNameInfo()); d1906 1 a1906 1 Record.AddStmt(VE); d1908 1 a1908 1 Record.AddStmt(VE); d1910 1 a1910 1 Record.AddStmt(E); d1912 1 a1912 1 Record.AddStmt(E); d1914 1 a1914 1 Record.AddStmt(E); d1919 2 a1920 3 VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); d1922 1 a1922 1 Record.AddSourceLocation(C->getModifierLoc()); d1924 1 a1924 1 Record.AddStmt(VE); d1927 1 a1927 1 Record.AddStmt(VE); d1930 1 a1930 1 Record.AddStmt(VE); d1933 1 a1933 1 Record.AddStmt(VE); d1936 1 a1936 1 Record.AddStmt(VE); d1938 2 a1939 2 Record.AddStmt(C->getStep()); Record.AddStmt(C->getCalcStep()); d1944 2 a1945 2 Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); d1947 2 a1948 2 Record.AddStmt(VE); Record.AddStmt(C->getAlignment()); d1953 1 a1953 1 Record.AddSourceLocation(C->getLParenLoc()); d1955 1 a1955 1 Record.AddStmt(VE); d1957 1 a1957 1 Record.AddStmt(E); d1959 1 a1959 1 Record.AddStmt(E); d1961 1 a1961 1 Record.AddStmt(E); d1966 1 a1966 1 Record.AddSourceLocation(C->getLParenLoc()); d1968 1 a1968 1 Record.AddStmt(VE); d1970 1 a1970 1 Record.AddStmt(E); d1972 1 a1972 1 Record.AddStmt(E); d1974 1 a1974 1 Record.AddStmt(E); d1979 1 a1979 1 Record.AddSourceLocation(C->getLParenLoc()); d1981 1 a1981 1 Record.AddStmt(VE); d1986 1 a1986 1 Record.AddSourceLocation(C->getLParenLoc()); d1988 2 a1989 2 Record.AddSourceLocation(C->getDependencyLoc()); Record.AddSourceLocation(C->getColonLoc()); d1991 1 a1991 2 Record.AddStmt(VE); Record.AddStmt(C->getCounterValue()); d1995 2 a1996 2 Record.AddStmt(C->getDevice()); Record.AddSourceLocation(C->getLParenLoc()); d2001 1 a2001 4 Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); d2004 4 a2007 14 Record.AddSourceLocation(C->getMapLoc()); Record.AddSourceLocation(C->getColonLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } d2011 2 a2012 2 Record.AddStmt(C->getNumTeams()); Record.AddSourceLocation(C->getLParenLoc()); d2016 2 a2017 2 Record.AddStmt(C->getThreadLimit()); Record.AddSourceLocation(C->getLParenLoc()); d2021 2 a2022 2 Record.AddStmt(C->getPriority()); Record.AddSourceLocation(C->getLParenLoc()); d2026 2 a2027 2 Record.AddStmt(C->getGrainsize()); Record.AddSourceLocation(C->getLParenLoc()); d2031 2 a2032 2 Record.AddStmt(C->getNumTasks()); Record.AddSourceLocation(C->getLParenLoc()); d2036 2 a2037 103 Record.AddStmt(C->getHint()); Record.AddSourceLocation(C->getLParenLoc()); } void OMPClauseWriter::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) { VisitOMPClauseWithPreInit(C); Record.push_back(C->getDistScheduleKind()); Record.AddStmt(C->getChunkSize()); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getDistScheduleKindLoc()); Record.AddSourceLocation(C->getCommaLoc()); } void OMPClauseWriter::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) { Record.push_back(C->getDefaultmapKind()); Record.push_back(C->getDefaultmapModifier()); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getDefaultmapModifierLoc()); Record.AddSourceLocation(C->getDefaultmapKindLoc()); } void OMPClauseWriter::VisitOMPToClause(OMPToClause *C) { Record.push_back(C->varlist_size()); Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } } void OMPClauseWriter::VisitOMPFromClause(OMPFromClause *C) { Record.push_back(C->varlist_size()); Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } } void OMPClauseWriter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) { Record.push_back(C->varlist_size()); Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *VE : C->private_copies()) Record.AddStmt(VE); for (auto *VE : C->inits()) Record.AddStmt(VE); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } } void OMPClauseWriter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) { Record.push_back(C->varlist_size()); Record.push_back(C->getUniqueDeclarationsNum()); Record.push_back(C->getTotalComponentListNum()); Record.push_back(C->getTotalComponentsNum()); Record.AddSourceLocation(C->getLParenLoc()); for (auto *E : C->varlists()) Record.AddStmt(E); for (auto *D : C->all_decls()) Record.AddDeclRef(D); for (auto N : C->all_num_lists()) Record.push_back(N); for (auto N : C->all_lists_sizes()) Record.push_back(N); for (auto &M : C->all_components()) { Record.AddStmt(M.getAssociatedExpression()); Record.AddDeclRef(M.getAssociatedDeclaration()); } d2044 3 a2046 3 Record.AddSourceLocation(E->getLocStart()); Record.AddSourceLocation(E->getLocEnd()); OMPClauseWriter ClauseWriter(Record); d2051 1 a2051 1 Record.AddStmt(E->getAssociatedStmt()); d2059 15 a2073 23 Record.AddStmt(D->getIterationVariable()); Record.AddStmt(D->getLastIteration()); Record.AddStmt(D->getCalcLastIteration()); Record.AddStmt(D->getPreCond()); Record.AddStmt(D->getCond()); Record.AddStmt(D->getInit()); Record.AddStmt(D->getInc()); Record.AddStmt(D->getPreInits()); if (isOpenMPWorksharingDirective(D->getDirectiveKind()) || isOpenMPTaskLoopDirective(D->getDirectiveKind()) || isOpenMPDistributeDirective(D->getDirectiveKind())) { Record.AddStmt(D->getIsLastIterVariable()); Record.AddStmt(D->getLowerBoundVariable()); Record.AddStmt(D->getUpperBoundVariable()); Record.AddStmt(D->getStrideVariable()); Record.AddStmt(D->getEnsureUpperBound()); Record.AddStmt(D->getNextLowerBound()); Record.AddStmt(D->getNextUpperBound()); Record.AddStmt(D->getNumIterations()); } if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) { Record.AddStmt(D->getPrevLowerBoundVariable()); Record.AddStmt(D->getPrevUpperBoundVariable()); d2076 1 a2076 1 Record.AddStmt(I); d2079 1 a2079 1 Record.AddStmt(I); d2082 1 a2082 1 Record.AddStmt(I); d2085 1 a2085 1 Record.AddStmt(I); d2088 1 a2088 1 Record.AddStmt(I); d2148 1 a2148 1 Record.AddDeclarationNameInfo(D->getDirectiveName()); d2185 4 a2188 4 Record.AddStmt(D->getX()); Record.AddStmt(D->getV()); Record.AddStmt(D->getExpr()); Record.AddStmt(D->getUpdateExpr()); a2207 31 void ASTStmtWriter::VisitOMPTargetEnterDataDirective( OMPTargetEnterDataDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetExitDataDirective( OMPTargetExitDataDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetParallelDirective( OMPTargetParallelDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetParallelForDirective( OMPTargetParallelForDirective *D) { VisitOMPLoopDirective(D); Record.push_back(D->hasCancel() ? 1 : 0); Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE; } a2283 86 void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE; } void ASTStmtWriter::VisitOMPDistributeParallelForDirective( OMPDistributeParallelForDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective( OMPDistributeParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPDistributeSimdDirective( OMPDistributeSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective( OMPTargetParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTeamsDistributeDirective( OMPTeamsDistributeDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE; } void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective( OMPTeamsDistributeSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective( OMPTeamsDistributeParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective( OMPTeamsDistributeParallelForDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective( OMPTargetTeamsDistributeDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective( OMPTargetTeamsDistributeParallelForDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective( OMPTargetTeamsDistributeParallelForSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization:: STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE; } d2308 3 a2310 1 void ASTWriter::WriteSubStmt(Stmt *S) { d2346 6 d2354 22 a2375 2 uint64_t Offset = Writer.Emit(); SubStmtEntries[S] = Offset; d2380 3 a2382 1 void ASTRecordWriter::FlushStmts() { d2385 2 a2386 2 assert(Writer->SubStmtEntries.empty() && "unexpected entries in sub-stmt map"); assert(Writer->ParentStmts.empty() && "unexpected entries in parent stmt map"); d2389 1 a2389 1 Writer->WriteSubStmt(StmtsToEmit[I]); d2391 2 a2392 1 assert(N == StmtsToEmit.size() && "record modified while being written!"); d2397 1 a2397 5 Writer->Stream.EmitRecord(serialization::STMT_STOP, ArrayRef()); Writer->SubStmtEntries.clear(); Writer->ParentStmts.clear(); } d2399 2 a2400 10 StmtsToEmit.clear(); } void ASTRecordWriter::FlushSubStmts() { // For a nested statement, write out the substatements in reverse order (so // that a simple stack machine can be used when loading), and don't emit a // STMT_STOP after each one. for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { Writer->WriteSubStmt(StmtsToEmit[N - I - 1]); assert(N == StmtsToEmit.size() && "record modified while being written!"); @ 1.1.1.8.2.1 log @Sync with HEAD @ text @a2565 6 void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective( OMPTargetTeamsDistributeSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE; } @ 1.1.1.9 log @Import Clang 4.0RC1 r294123. @ text @a2565 6 void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective( OMPTargetTeamsDistributeSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE; } @ 1.1.1.10 log @Import clang r309604 from branches/release_50 @ text @a317 5 void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *S) { // FIXME: Implement coroutine serialization. llvm_unreachable("unimplemented"); } d648 1 a648 1 Record.push_back(E->getFPFeatures().getInt()); d1216 1 a1216 1 Record.push_back(E->getFPFeatures().getInt()); a1796 1 Record.push_back(C->getCaptureRegion()); a1805 1 VisitOMPClauseWithPreInit(C); a1818 1 VisitOMPClauseWithPreInit(C); a1957 19 void OMPClauseWriter::VisitOMPTaskReductionClause(OMPTaskReductionClause *C) { Record.push_back(C->varlist_size()); VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); Record.AddNestedNameSpecifierLoc(C->getQualifierLoc()); Record.AddDeclarationNameInfo(C->getNameInfo()); for (auto *VE : C->varlists()) Record.AddStmt(VE); for (auto *VE : C->privates()) Record.AddStmt(VE); for (auto *E : C->lhs_exprs()) Record.AddStmt(E); for (auto *E : C->rhs_exprs()) Record.AddStmt(E); for (auto *E : C->reduction_ops()) Record.AddStmt(E); } a2066 1 VisitOMPClauseWithPreInit(C); a2071 1 VisitOMPClauseWithPreInit(C); a2238 9 Record.AddStmt(D->getDistInc()); Record.AddStmt(D->getPrevEnsureUpperBound()); Record.AddStmt(D->getCombinedLowerBoundVariable()); Record.AddStmt(D->getCombinedUpperBoundVariable()); Record.AddStmt(D->getCombinedEnsureUpperBound()); Record.AddStmt(D->getCombinedInit()); Record.AddStmt(D->getCombinedCond()); Record.AddStmt(D->getCombinedNextLowerBound()); Record.AddStmt(D->getCombinedNextUpperBound()); a2423 1 Record.push_back(D->getNumClauses()); @ 1.1.1.11 log @Import clang r319952 from branches/release_50 @ text @d289 1 a289 1 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { d303 3 a305 6 void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *CoroStmt) { VisitStmt(CoroStmt); Record.push_back(CoroStmt->getParamMoves().size()); for (Stmt *S : CoroStmt->children()) Record.AddStmt(S); Code = serialization::STMT_COROUTINE_BODY; d309 2 a310 14 VisitStmt(S); Record.AddSourceLocation(S->getKeywordLoc()); Record.AddStmt(S->getOperand()); Record.AddStmt(S->getPromiseCall()); Record.push_back(S->isImplicit()); Code = serialization::STMT_CORETURN; } void ASTStmtWriter::VisitCoroutineSuspendExpr(CoroutineSuspendExpr *E) { VisitExpr(E); Record.AddSourceLocation(E->getKeywordLoc()); for (Stmt *S : E->children()) Record.AddStmt(S); Record.AddStmt(E->getOpaqueValue()); d313 3 a315 4 void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *E) { VisitCoroutineSuspendExpr(E); Record.push_back(E->isImplicit()); Code = serialization::EXPR_COAWAIT; d318 3 a320 3 void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *E) { VisitCoroutineSuspendExpr(E); Code = serialization::EXPR_COYIELD; d323 3 a325 6 void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) { VisitExpr(E); Record.AddSourceLocation(E->getKeywordLoc()); for (Stmt *S : E->children()) Record.AddStmt(S); Code = serialization::EXPR_DEPENDENT_COAWAIT; @ 1.1.1.11.4.1 log @Sync with HEAD @ text @d11 1 a11 1 /// Implements serialization for Statements and Expressions. a446 7 void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) { VisitExpr(E); Record.AddSourceLocation(E->getLocation()); Record.AddAPInt(E->getValue()); Code = serialization::EXPR_INTEGER_LITERAL; } a511 1 Record.push_back(E->canOverflow()); a1700 1 Record.push_back(E->isUnique()); a2003 21 void OMPClauseWriter::VisitOMPInReductionClause(OMPInReductionClause *C) { Record.push_back(C->varlist_size()); VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); Record.AddNestedNameSpecifierLoc(C->getQualifierLoc()); Record.AddDeclarationNameInfo(C->getNameInfo()); for (auto *VE : C->varlists()) Record.AddStmt(VE); for (auto *VE : C->privates()) Record.AddStmt(VE); for (auto *E : C->lhs_exprs()) Record.AddStmt(E); for (auto *E : C->rhs_exprs()) Record.AddStmt(E); for (auto *E : C->reduction_ops()) Record.AddStmt(E); for (auto *E : C->taskgroup_descriptors()) Record.AddStmt(E); } a2083 1 VisitOMPClauseWithPreInit(C); a2482 1 Record.AddStmt(D->getReductionRef()); a2547 1 Record.push_back(D->hasCancel() ? 1 : 0); a2594 1 Record.push_back(D->hasCancel() ? 1 : 0); a2613 1 Record.push_back(D->hasCancel() ? 1 : 0); d2652 1 a2652 1 /// Write the given substatement or subexpression to the d2696 1 a2696 1 /// Flush all of the statements that have been added to the @ 1.1.1.11.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.11.2.1 log @Sync with HEAD @ text @d11 1 a11 1 /// Implements serialization for Statements and Expressions. a446 7 void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) { VisitExpr(E); Record.AddSourceLocation(E->getLocation()); Record.AddAPInt(E->getValue()); Code = serialization::EXPR_INTEGER_LITERAL; } a511 1 Record.push_back(E->canOverflow()); a1700 1 Record.push_back(E->isUnique()); a2003 21 void OMPClauseWriter::VisitOMPInReductionClause(OMPInReductionClause *C) { Record.push_back(C->varlist_size()); VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); Record.AddNestedNameSpecifierLoc(C->getQualifierLoc()); Record.AddDeclarationNameInfo(C->getNameInfo()); for (auto *VE : C->varlists()) Record.AddStmt(VE); for (auto *VE : C->privates()) Record.AddStmt(VE); for (auto *E : C->lhs_exprs()) Record.AddStmt(E); for (auto *E : C->rhs_exprs()) Record.AddStmt(E); for (auto *E : C->reduction_ops()) Record.AddStmt(E); for (auto *E : C->taskgroup_descriptors()) Record.AddStmt(E); } a2083 1 VisitOMPClauseWithPreInit(C); a2482 1 Record.AddStmt(D->getReductionRef()); a2547 1 Record.push_back(D->hasCancel() ? 1 : 0); a2594 1 Record.push_back(D->hasCancel() ? 1 : 0); a2613 1 Record.push_back(D->hasCancel() ? 1 : 0); d2652 1 a2652 1 /// Write the given substatement or subexpression to the d2696 1 a2696 1 /// Flush all of the statements that have been added to the @ 1.1.1.12 log @Import clang r337282 from trunk @ text @d11 1 a11 1 /// Implements serialization for Statements and Expressions. a446 7 void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) { VisitExpr(E); Record.AddSourceLocation(E->getLocation()); Record.AddAPInt(E->getValue()); Code = serialization::EXPR_INTEGER_LITERAL; } a511 1 Record.push_back(E->canOverflow()); a1700 1 Record.push_back(E->isUnique()); a2003 21 void OMPClauseWriter::VisitOMPInReductionClause(OMPInReductionClause *C) { Record.push_back(C->varlist_size()); VisitOMPClauseWithPostUpdate(C); Record.AddSourceLocation(C->getLParenLoc()); Record.AddSourceLocation(C->getColonLoc()); Record.AddNestedNameSpecifierLoc(C->getQualifierLoc()); Record.AddDeclarationNameInfo(C->getNameInfo()); for (auto *VE : C->varlists()) Record.AddStmt(VE); for (auto *VE : C->privates()) Record.AddStmt(VE); for (auto *E : C->lhs_exprs()) Record.AddStmt(E); for (auto *E : C->rhs_exprs()) Record.AddStmt(E); for (auto *E : C->reduction_ops()) Record.AddStmt(E); for (auto *E : C->taskgroup_descriptors()) Record.AddStmt(E); } a2083 1 VisitOMPClauseWithPreInit(C); a2482 1 Record.AddStmt(D->getReductionRef()); a2547 1 Record.push_back(D->hasCancel() ? 1 : 0); a2594 1 Record.push_back(D->hasCancel() ? 1 : 0); a2613 1 Record.push_back(D->hasCancel() ? 1 : 0); d2652 1 a2652 1 /// Write the given substatement or subexpression to the d2696 1 a2696 1 /// Flush all of the statements that have been added to the @ 1.1.1.13 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file ASTWriterStmt.cpp was added on branch tls-maxphys on 2014-08-19 23:47:31 +0000 @ text @d1 2082 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 2082 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief Implements serialization for Statements and Expressions. /// //===----------------------------------------------------------------------===// #include "clang/Serialization/ASTWriter.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/StmtVisitor.h" #include "clang/Lex/Token.h" #include "llvm/Bitcode/BitstreamWriter.h" using namespace clang; //===----------------------------------------------------------------------===// // Statement/expression serialization //===----------------------------------------------------------------------===// namespace clang { class ASTStmtWriter : public StmtVisitor { friend class OMPClauseWriter; ASTWriter &Writer; ASTWriter::RecordData &Record; public: serialization::StmtCode Code; unsigned AbbrevToUse; ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record) : Writer(Writer), Record(Record) { } void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &Args); void VisitStmt(Stmt *S); #define STMT(Type, Base) \ void Visit##Type(Type *); #include "clang/AST/StmtNodes.inc" }; } void ASTStmtWriter:: AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &Args) { Writer.AddSourceLocation(Args.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(Args.LAngleLoc, Record); Writer.AddSourceLocation(Args.RAngleLoc, Record); for (unsigned i=0; i != Args.NumTemplateArgs; ++i) Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record); } void ASTStmtWriter::VisitStmt(Stmt *S) { } void ASTStmtWriter::VisitNullStmt(NullStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getSemiLoc(), Record); Record.push_back(S->HasLeadingEmptyMacro); Code = serialization::STMT_NULL; } void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) { VisitStmt(S); Record.push_back(S->size()); for (auto *CS : S->body()) Writer.AddStmt(CS); Writer.AddSourceLocation(S->getLBracLoc(), Record); Writer.AddSourceLocation(S->getRBracLoc(), Record); Code = serialization::STMT_COMPOUND; } void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) { VisitStmt(S); Record.push_back(Writer.getSwitchCaseID(S)); Writer.AddSourceLocation(S->getKeywordLoc(), Record); Writer.AddSourceLocation(S->getColonLoc(), Record); } void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) { VisitSwitchCase(S); Writer.AddStmt(S->getLHS()); Writer.AddStmt(S->getRHS()); Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getEllipsisLoc(), Record); Code = serialization::STMT_CASE; } void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) { VisitSwitchCase(S); Writer.AddStmt(S->getSubStmt()); Code = serialization::STMT_DEFAULT; } void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getDecl(), Record); Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getIdentLoc(), Record); Code = serialization::STMT_LABEL; } void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) { VisitStmt(S); Record.push_back(S->getAttrs().size()); Writer.WriteAttributes(S->getAttrs(), Record); Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getAttrLoc(), Record); Code = serialization::STMT_ATTRIBUTED; } void ASTStmtWriter::VisitIfStmt(IfStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getThen()); Writer.AddStmt(S->getElse()); Writer.AddSourceLocation(S->getIfLoc(), Record); Writer.AddSourceLocation(S->getElseLoc(), Record); Code = serialization::STMT_IF; } void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getSwitchLoc(), Record); Record.push_back(S->isAllEnumCasesCovered()); for (SwitchCase *SC = S->getSwitchCaseList(); SC; SC = SC->getNextSwitchCase()) Record.push_back(Writer.RecordSwitchCaseID(SC)); Code = serialization::STMT_SWITCH; } void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getWhileLoc(), Record); Code = serialization::STMT_WHILE; } void ASTStmtWriter::VisitDoStmt(DoStmt *S) { VisitStmt(S); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getDoLoc(), Record); Writer.AddSourceLocation(S->getWhileLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_DO; } void ASTStmtWriter::VisitForStmt(ForStmt *S) { VisitStmt(S); Writer.AddStmt(S->getInit()); Writer.AddStmt(S->getCond()); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getInc()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getLParenLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_FOR; } void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getLabel(), Record); Writer.AddSourceLocation(S->getGotoLoc(), Record); Writer.AddSourceLocation(S->getLabelLoc(), Record); Code = serialization::STMT_GOTO; } void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getGotoLoc(), Record); Writer.AddSourceLocation(S->getStarLoc(), Record); Writer.AddStmt(S->getTarget()); Code = serialization::STMT_INDIRECT_GOTO; } void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getContinueLoc(), Record); Code = serialization::STMT_CONTINUE; } void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getBreakLoc(), Record); Code = serialization::STMT_BREAK; } void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) { VisitStmt(S); Writer.AddStmt(S->getRetValue()); Writer.AddSourceLocation(S->getReturnLoc(), Record); Writer.AddDeclRef(S->getNRVOCandidate(), Record); Code = serialization::STMT_RETURN; } void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getStartLoc(), Record); Writer.AddSourceLocation(S->getEndLoc(), Record); DeclGroupRef DG = S->getDeclGroup(); for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D) Writer.AddDeclRef(*D, Record); Code = serialization::STMT_DECL; } void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) { VisitStmt(S); Record.push_back(S->getNumOutputs()); Record.push_back(S->getNumInputs()); Record.push_back(S->getNumClobbers()); Writer.AddSourceLocation(S->getAsmLoc(), Record); Record.push_back(S->isVolatile()); Record.push_back(S->isSimple()); } void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) { VisitAsmStmt(S); Writer.AddSourceLocation(S->getRParenLoc(), Record); Writer.AddStmt(S->getAsmString()); // Outputs for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record); Writer.AddStmt(S->getOutputConstraintLiteral(I)); Writer.AddStmt(S->getOutputExpr(I)); } // Inputs for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { Writer.AddIdentifierRef(S->getInputIdentifier(I), Record); Writer.AddStmt(S->getInputConstraintLiteral(I)); Writer.AddStmt(S->getInputExpr(I)); } // Clobbers for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) Writer.AddStmt(S->getClobberStringLiteral(I)); Code = serialization::STMT_GCCASM; } void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) { VisitAsmStmt(S); Writer.AddSourceLocation(S->getLBraceLoc(), Record); Writer.AddSourceLocation(S->getEndLoc(), Record); Record.push_back(S->getNumAsmToks()); Writer.AddString(S->getAsmString(), Record); // Tokens for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) { Writer.AddToken(S->getAsmToks()[I], Record); } // Clobbers for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) { Writer.AddString(S->getClobber(I), Record); } // Outputs for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { Writer.AddStmt(S->getOutputExpr(I)); Writer.AddString(S->getOutputConstraint(I), Record); } // Inputs for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { Writer.AddStmt(S->getInputExpr(I)); Writer.AddString(S->getInputConstraint(I), Record); } Code = serialization::STMT_MSASM; } void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) { VisitStmt(S); // NumCaptures Record.push_back(std::distance(S->capture_begin(), S->capture_end())); // CapturedDecl and captured region kind Writer.AddDeclRef(S->getCapturedDecl(), Record); Record.push_back(S->getCapturedRegionKind()); Writer.AddDeclRef(S->getCapturedRecordDecl(), Record); // Capture inits for (auto *I : S->capture_inits()) Writer.AddStmt(I); // Body Writer.AddStmt(S->getCapturedStmt()); // Captures for (const auto &I : S->captures()) { if (I.capturesThis()) Writer.AddDeclRef(nullptr, Record); else Writer.AddDeclRef(I.getCapturedVar(), Record); Record.push_back(I.getCaptureKind()); Writer.AddSourceLocation(I.getLocation(), Record); } Code = serialization::STMT_CAPTURED; } void ASTStmtWriter::VisitExpr(Expr *E) { VisitStmt(E); Writer.AddTypeRef(E->getType(), Record); Record.push_back(E->isTypeDependent()); Record.push_back(E->isValueDependent()); Record.push_back(E->isInstantiationDependent()); Record.push_back(E->containsUnexpandedParameterPack()); Record.push_back(E->getValueKind()); Record.push_back(E->getObjectKind()); } void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->getIdentType()); // FIXME: stable encoding Code = serialization::EXPR_PREDEFINED; } void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) { VisitExpr(E); Record.push_back(E->hasQualifier()); Record.push_back(E->getDecl() != E->getFoundDecl()); Record.push_back(E->hasTemplateKWAndArgsInfo()); Record.push_back(E->hadMultipleCandidates()); Record.push_back(E->refersToEnclosingLocal()); if (E->hasTemplateKWAndArgsInfo()) { unsigned NumTemplateArgs = E->getNumTemplateArgs(); Record.push_back(NumTemplateArgs); } DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind()); if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) && (E->getDecl() == E->getFoundDecl()) && nk == DeclarationName::Identifier) { AbbrevToUse = Writer.getDeclRefExprAbbrev(); } if (E->hasQualifier()) Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); if (E->getDecl() != E->getFoundDecl()) Writer.AddDeclRef(E->getFoundDecl(), Record); if (E->hasTemplateKWAndArgsInfo()) AddTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo()); Writer.AddDeclRef(E->getDecl(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record); Code = serialization::EXPR_DECL_REF; } void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddAPInt(E->getValue(), Record); if (E->getValue().getBitWidth() == 32) { AbbrevToUse = Writer.getIntegerLiteralAbbrev(); } Code = serialization::EXPR_INTEGER_LITERAL; } void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) { VisitExpr(E); Record.push_back(E->getRawSemantics()); Record.push_back(E->isExact()); Writer.AddAPFloat(E->getValue(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_FLOATING_LITERAL; } void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_IMAGINARY_LITERAL; } void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) { VisitExpr(E); Record.push_back(E->getByteLength()); Record.push_back(E->getNumConcatenated()); Record.push_back(E->getKind()); Record.push_back(E->isPascal()); // FIXME: String data should be stored as a blob at the end of the // StringLiteral. However, we can't do so now because we have no // provision for coping with abbreviations when we're jumping around // the AST file during deserialization. Record.append(E->getBytes().begin(), E->getBytes().end()); for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I) Writer.AddSourceLocation(E->getStrTokenLoc(I), Record); Code = serialization::EXPR_STRING_LITERAL; } void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->getKind()); AbbrevToUse = Writer.getCharacterLiteralAbbrev(); Code = serialization::EXPR_CHARACTER_LITERAL; } void ASTStmtWriter::VisitParenExpr(ParenExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParen(), Record); Writer.AddSourceLocation(E->getRParen(), Record); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_PAREN; } void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) { VisitExpr(E); Record.push_back(E->NumExprs); for (unsigned i=0; i != E->NumExprs; ++i) Writer.AddStmt(E->Exprs[i]); Writer.AddSourceLocation(E->LParenLoc, Record); Writer.AddSourceLocation(E->RParenLoc, Record); Code = serialization::EXPR_PAREN_LIST; } void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = serialization::EXPR_UNARY_OPERATOR; } void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) { VisitExpr(E); Record.push_back(E->getNumComponents()); Record.push_back(E->getNumExpressions()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { const OffsetOfExpr::OffsetOfNode &ON = E->getComponent(I); Record.push_back(ON.getKind()); // FIXME: Stable encoding Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record); Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record); switch (ON.getKind()) { case OffsetOfExpr::OffsetOfNode::Array: Record.push_back(ON.getArrayExprIndex()); break; case OffsetOfExpr::OffsetOfNode::Field: Writer.AddDeclRef(ON.getField(), Record); break; case OffsetOfExpr::OffsetOfNode::Identifier: Writer.AddIdentifierRef(ON.getFieldName(), Record); break; case OffsetOfExpr::OffsetOfNode::Base: Writer.AddCXXBaseSpecifier(*ON.getBase(), Record); break; } } for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) Writer.AddStmt(E->getIndexExpr(I)); Code = serialization::EXPR_OFFSETOF; } void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->getKind()); if (E->isArgumentType()) Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record); else { Record.push_back(0); Writer.AddStmt(E->getArgumentExpr()); } Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_SIZEOF_ALIGN_OF; } void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { VisitExpr(E); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getRBracketLoc(), Record); Code = serialization::EXPR_ARRAY_SUBSCRIPT; } void ASTStmtWriter::VisitCallExpr(CallExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddStmt(E->getCallee()); for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) Writer.AddStmt(*Arg); Code = serialization::EXPR_CALL; } void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) { // Don't call VisitExpr, we'll write everything here. Record.push_back(E->hasQualifier()); if (E->hasQualifier()) Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { Writer.AddSourceLocation(E->getTemplateKeywordLoc(), Record); unsigned NumTemplateArgs = E->getNumTemplateArgs(); Record.push_back(NumTemplateArgs); Writer.AddSourceLocation(E->getLAngleLoc(), Record); Writer.AddSourceLocation(E->getRAngleLoc(), Record); for (unsigned i=0; i != NumTemplateArgs; ++i) Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record); } Record.push_back(E->hadMultipleCandidates()); DeclAccessPair FoundDecl = E->getFoundDecl(); Writer.AddDeclRef(FoundDecl.getDecl(), Record); Record.push_back(FoundDecl.getAccess()); Writer.AddTypeRef(E->getType(), Record); Record.push_back(E->getValueKind()); Record.push_back(E->getObjectKind()); Writer.AddStmt(E->getBase()); Writer.AddDeclRef(E->getMemberDecl(), Record); Writer.AddSourceLocation(E->getMemberLoc(), Record); Record.push_back(E->isArrow()); Writer.AddDeclarationNameLoc(E->MemberDNLoc, E->getMemberDecl()->getDeclName(), Record); Code = serialization::EXPR_MEMBER; } void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Writer.AddSourceLocation(E->getIsaMemberLoc(), Record); Writer.AddSourceLocation(E->getOpLoc(), Record); Record.push_back(E->isArrow()); Code = serialization::EXPR_OBJC_ISA; } void ASTStmtWriter:: VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->shouldCopy()); Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE; } void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getBridgeKeywordLoc(), Record); Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding Code = serialization::EXPR_OBJC_BRIDGED_CAST; } void ASTStmtWriter::VisitCastExpr(CastExpr *E) { VisitExpr(E); Record.push_back(E->path_size()); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->getCastKind()); // FIXME: stable encoding for (CastExpr::path_iterator PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI) Writer.AddCXXBaseSpecifier(**PI, Record); } void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) { VisitExpr(E); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Record.push_back(E->isFPContractable()); Code = serialization::EXPR_BINARY_OPERATOR; } void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { VisitBinaryOperator(E); Writer.AddTypeRef(E->getComputationLHSType(), Record); Writer.AddTypeRef(E->getComputationResultType(), Record); Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR; } void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) { VisitExpr(E); Writer.AddStmt(E->getCond()); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getQuestionLoc(), Record); Writer.AddSourceLocation(E->getColonLoc(), Record); Code = serialization::EXPR_CONDITIONAL_OPERATOR; } void ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { VisitExpr(E); Writer.AddStmt(E->getOpaqueValue()); Writer.AddStmt(E->getCommon()); Writer.AddStmt(E->getCond()); Writer.AddStmt(E->getTrueExpr()); Writer.AddStmt(E->getFalseExpr()); Writer.AddSourceLocation(E->getQuestionLoc(), Record); Writer.AddSourceLocation(E->getColonLoc(), Record); Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR; } void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) { VisitCastExpr(E); if (E->path_size() == 0) AbbrevToUse = Writer.getExprImplicitCastAbbrev(); Code = serialization::EXPR_IMPLICIT_CAST; } void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) { VisitCastExpr(E); Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record); } void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CSTYLE_CAST; } void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddStmt(E->getInitializer()); Record.push_back(E->isFileScope()); Code = serialization::EXPR_COMPOUND_LITERAL; } void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Writer.AddIdentifierRef(&E->getAccessor(), Record); Writer.AddSourceLocation(E->getAccessorLoc(), Record); Code = serialization::EXPR_EXT_VECTOR_ELEMENT; } void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) { VisitExpr(E); // NOTE: only add the (possibly null) syntactic form. // No need to serialize the isSemanticForm flag and the semantic form. Writer.AddStmt(E->getSyntacticForm()); Writer.AddSourceLocation(E->getLBraceLoc(), Record); Writer.AddSourceLocation(E->getRBraceLoc(), Record); bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is(); Record.push_back(isArrayFiller); if (isArrayFiller) Writer.AddStmt(E->getArrayFiller()); else Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record); Record.push_back(E->hadArrayRangeDesignator()); Record.push_back(E->getNumInits()); if (isArrayFiller) { // ArrayFiller may have filled "holes" due to designated initializer. // Replace them by 0 to indicate that the filler goes in that place. Expr *filler = E->getArrayFiller(); for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr); } else { for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) Writer.AddStmt(E->getInit(I)); } Code = serialization::EXPR_INIT_LIST; } void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) Writer.AddStmt(E->getSubExpr(I)); Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record); Record.push_back(E->usesGNUSyntax()); for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), DEnd = E->designators_end(); D != DEnd; ++D) { if (D->isFieldDesignator()) { if (FieldDecl *Field = D->getField()) { Record.push_back(serialization::DESIG_FIELD_DECL); Writer.AddDeclRef(Field, Record); } else { Record.push_back(serialization::DESIG_FIELD_NAME); Writer.AddIdentifierRef(D->getFieldName(), Record); } Writer.AddSourceLocation(D->getDotLoc(), Record); Writer.AddSourceLocation(D->getFieldLoc(), Record); } else if (D->isArrayDesignator()) { Record.push_back(serialization::DESIG_ARRAY); Record.push_back(D->getFirstExprIndex()); Writer.AddSourceLocation(D->getLBracketLoc(), Record); Writer.AddSourceLocation(D->getRBracketLoc(), Record); } else { assert(D->isArrayRangeDesignator() && "Unknown designator"); Record.push_back(serialization::DESIG_ARRAY_RANGE); Record.push_back(D->getFirstExprIndex()); Writer.AddSourceLocation(D->getLBracketLoc(), Record); Writer.AddSourceLocation(D->getEllipsisLoc(), Record); Writer.AddSourceLocation(D->getRBracketLoc(), Record); } } Code = serialization::EXPR_DESIGNATED_INIT; } void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { VisitExpr(E); Code = serialization::EXPR_IMPLICIT_VALUE_INIT; } void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_VA_ARG; } void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getAmpAmpLoc(), Record); Writer.AddSourceLocation(E->getLabelLoc(), Record); Writer.AddDeclRef(E->getLabel(), Record); Code = serialization::EXPR_ADDR_LABEL; } void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubStmt()); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_STMT; } void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) { VisitExpr(E); Writer.AddStmt(E->getCond()); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue()); Code = serialization::EXPR_CHOOSE; } void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getTokenLocation(), Record); Code = serialization::EXPR_GNU_NULL; } void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) Writer.AddStmt(E->getExpr(I)); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_SHUFFLE_VECTOR; } void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddStmt(E->getSrcExpr()); Code = serialization::EXPR_CONVERT_VECTOR; } void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getBlockDecl(), Record); Code = serialization::EXPR_BLOCK; } void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) { VisitExpr(E); Record.push_back(E->getNumAssocs()); Writer.AddStmt(E->getControllingExpr()); for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) { Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record); Writer.AddStmt(E->getAssocExpr(I)); } Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex()); Writer.AddSourceLocation(E->getGenericLoc(), Record); Writer.AddSourceLocation(E->getDefaultLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_GENERIC_SELECTION; } void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) { VisitExpr(E); Record.push_back(E->getNumSemanticExprs()); // Push the result index. Currently, this needs to exactly match // the encoding used internally for ResultIndex. unsigned result = E->getResultExprIndex(); result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1); Record.push_back(result); Writer.AddStmt(E->getSyntacticForm()); for (PseudoObjectExpr::semantics_iterator i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) { Writer.AddStmt(*i); } Code = serialization::EXPR_PSEUDO_OBJECT; } void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) { VisitExpr(E); Record.push_back(E->getOp()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) Writer.AddStmt(E->getSubExprs()[I]); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_ATOMIC; } //===----------------------------------------------------------------------===// // Objective-C Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) { VisitExpr(E); Writer.AddStmt(E->getString()); Writer.AddSourceLocation(E->getAtLoc(), Record); Code = serialization::EXPR_OBJC_STRING_LITERAL; } void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Writer.AddDeclRef(E->getBoxingMethod(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Code = serialization::EXPR_OBJC_BOXED_EXPRESSION; } void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { VisitExpr(E); Record.push_back(E->getNumElements()); for (unsigned i = 0; i < E->getNumElements(); i++) Writer.AddStmt(E->getElement(i)); Writer.AddDeclRef(E->getArrayWithObjectsMethod(), Record); Writer.AddDeclRef(E->getArrayAllocMethod(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Code = serialization::EXPR_OBJC_ARRAY_LITERAL; } void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { VisitExpr(E); Record.push_back(E->getNumElements()); Record.push_back(E->HasPackExpansions); for (unsigned i = 0; i < E->getNumElements(); i++) { ObjCDictionaryElement Element = E->getKeyValueElement(i); Writer.AddStmt(Element.Key); Writer.AddStmt(Element.Value); if (E->HasPackExpansions) { Writer.AddSourceLocation(Element.EllipsisLoc, Record); unsigned NumExpansions = 0; if (Element.NumExpansions) NumExpansions = *Element.NumExpansions + 1; Record.push_back(NumExpansions); } } Writer.AddDeclRef(E->getDictWithObjectsMethod(), Record); Writer.AddDeclRef(E->getDictAllocMethod(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL; } void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { VisitExpr(E); Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_OBJC_ENCODE; } void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { VisitExpr(E); Writer.AddSelectorRef(E->getSelector(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_OBJC_SELECTOR_EXPR; } void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getProtocol(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); Writer.AddSourceLocation(E->ProtoLoc, Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_OBJC_PROTOCOL_EXPR; } void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getDecl(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddSourceLocation(E->getOpLoc(), Record); Writer.AddStmt(E->getBase()); Record.push_back(E->isArrow()); Record.push_back(E->isFreeIvar()); Code = serialization::EXPR_OBJC_IVAR_REF_EXPR; } void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { VisitExpr(E); Record.push_back(E->SetterAndMethodRefFlags.getInt()); Record.push_back(E->isImplicitProperty()); if (E->isImplicitProperty()) { Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record); Writer.AddDeclRef(E->getImplicitPropertySetter(), Record); } else { Writer.AddDeclRef(E->getExplicitProperty(), Record); } Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddSourceLocation(E->getReceiverLocation(), Record); if (E->isObjectReceiver()) { Record.push_back(0); Writer.AddStmt(E->getBase()); } else if (E->isSuperReceiver()) { Record.push_back(1); Writer.AddTypeRef(E->getSuperReceiverType(), Record); } else { Record.push_back(2); Writer.AddDeclRef(E->getClassReceiver(), Record); } Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR; } void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getRBracket(), Record); Writer.AddStmt(E->getBaseExpr()); Writer.AddStmt(E->getKeyExpr()); Writer.AddDeclRef(E->getAtIndexMethodDecl(), Record); Writer.AddDeclRef(E->setAtIndexMethodDecl(), Record); Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR; } void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); Record.push_back(E->getNumStoredSelLocs()); Record.push_back(E->SelLocsKind); Record.push_back(E->isDelegateInitCall()); Record.push_back(E->IsImplicit); Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding switch (E->getReceiverKind()) { case ObjCMessageExpr::Instance: Writer.AddStmt(E->getInstanceReceiver()); break; case ObjCMessageExpr::Class: Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record); break; case ObjCMessageExpr::SuperClass: case ObjCMessageExpr::SuperInstance: Writer.AddTypeRef(E->getSuperType(), Record); Writer.AddSourceLocation(E->getSuperLoc(), Record); break; } if (E->getMethodDecl()) { Record.push_back(1); Writer.AddDeclRef(E->getMethodDecl(), Record); } else { Record.push_back(0); Writer.AddSelectorRef(E->getSelector(), Record); } Writer.AddSourceLocation(E->getLeftLoc(), Record); Writer.AddSourceLocation(E->getRightLoc(), Record); for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) Writer.AddStmt(*Arg); SourceLocation *Locs = E->getStoredSelLocs(); for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i) Writer.AddSourceLocation(Locs[i], Record); Code = serialization::EXPR_OBJC_MESSAGE_EXPR; } void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { VisitStmt(S); Writer.AddStmt(S->getElement()); Writer.AddStmt(S->getCollection()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_OBJC_FOR_COLLECTION; } void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { Writer.AddStmt(S->getCatchBody()); Writer.AddDeclRef(S->getCatchParamDecl(), Record); Writer.AddSourceLocation(S->getAtCatchLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_OBJC_CATCH; } void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { Writer.AddStmt(S->getFinallyBody()); Writer.AddSourceLocation(S->getAtFinallyLoc(), Record); Code = serialization::STMT_OBJC_FINALLY; } void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getAtLoc(), Record); Code = serialization::STMT_OBJC_AUTORELEASE_POOL; } void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { Record.push_back(S->getNumCatchStmts()); Record.push_back(S->getFinallyStmt() != nullptr); Writer.AddStmt(S->getTryBody()); for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) Writer.AddStmt(S->getCatchStmt(I)); if (S->getFinallyStmt()) Writer.AddStmt(S->getFinallyStmt()); Writer.AddSourceLocation(S->getAtTryLoc(), Record); Code = serialization::STMT_OBJC_AT_TRY; } void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { Writer.AddStmt(S->getSynchExpr()); Writer.AddStmt(S->getSynchBody()); Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record); Code = serialization::STMT_OBJC_AT_SYNCHRONIZED; } void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { Writer.AddStmt(S->getThrowExpr()); Writer.AddSourceLocation(S->getThrowLoc(), Record); Code = serialization::STMT_OBJC_AT_THROW; } void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_OBJC_BOOL_LITERAL; } //===----------------------------------------------------------------------===// // C++ Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getCatchLoc(), Record); Writer.AddDeclRef(S->getExceptionDecl(), Record); Writer.AddStmt(S->getHandlerBlock()); Code = serialization::STMT_CXX_CATCH; } void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) { VisitStmt(S); Record.push_back(S->getNumHandlers()); Writer.AddSourceLocation(S->getTryLoc(), Record); Writer.AddStmt(S->getTryBlock()); for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) Writer.AddStmt(S->getHandler(i)); Code = serialization::STMT_CXX_TRY; } void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getColonLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Writer.AddStmt(S->getRangeStmt()); Writer.AddStmt(S->getBeginEndStmt()); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getInc()); Writer.AddStmt(S->getLoopVarStmt()); Writer.AddStmt(S->getBody()); Code = serialization::STMT_CXX_FOR_RANGE; } void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getKeywordLoc(), Record); Record.push_back(S->isIfExists()); Writer.AddNestedNameSpecifierLoc(S->getQualifierLoc(), Record); Writer.AddDeclarationNameInfo(S->getNameInfo(), Record); Writer.AddStmt(S->getSubStmt()); Code = serialization::STMT_MS_DEPENDENT_EXISTS; } void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { VisitCallExpr(E); Record.push_back(E->getOperator()); Writer.AddSourceRange(E->Range, Record); Record.push_back(E->isFPContractable()); Code = serialization::EXPR_CXX_OPERATOR_CALL; } void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { VisitCallExpr(E); Code = serialization::EXPR_CXX_MEMBER_CALL; } void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) Writer.AddStmt(E->getArg(I)); Writer.AddDeclRef(E->getConstructor(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->isElidable()); Record.push_back(E->hadMultipleCandidates()); Record.push_back(E->isListInitialization()); Record.push_back(E->isStdInitListInitialization()); Record.push_back(E->requiresZeroInitialization()); Record.push_back(E->getConstructionKind()); // FIXME: stable encoding Writer.AddSourceRange(E->getParenOrBraceRange(), Record); Code = serialization::EXPR_CXX_CONSTRUCT; } void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { VisitCXXConstructExpr(E); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Code = serialization::EXPR_CXX_TEMPORARY_OBJECT; } void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) { VisitExpr(E); Record.push_back(E->NumCaptures); unsigned NumArrayIndexVars = 0; if (E->HasArrayIndexVars) NumArrayIndexVars = E->getArrayIndexStarts()[E->NumCaptures]; Record.push_back(NumArrayIndexVars); Writer.AddSourceRange(E->IntroducerRange, Record); Record.push_back(E->CaptureDefault); // FIXME: stable encoding Writer.AddSourceLocation(E->CaptureDefaultLoc, Record); Record.push_back(E->ExplicitParams); Record.push_back(E->ExplicitResultType); Writer.AddSourceLocation(E->ClosingBrace, Record); // Add capture initializers. for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), CEnd = E->capture_init_end(); C != CEnd; ++C) { Writer.AddStmt(*C); } // Add array index variables, if any. if (NumArrayIndexVars) { Record.append(E->getArrayIndexStarts(), E->getArrayIndexStarts() + E->NumCaptures + 1); VarDecl **ArrayIndexVars = E->getArrayIndexVars(); for (unsigned I = 0; I != NumArrayIndexVars; ++I) Writer.AddDeclRef(ArrayIndexVars[I], Record); } Code = serialization::EXPR_LAMBDA; } void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST; } void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()), Record); Writer.AddSourceRange(E->getAngleBrackets(), Record); } void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_STATIC_CAST; } void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_DYNAMIC_CAST; } void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_REINTERPRET_CAST; } void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_CONST_CAST; } void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CXX_FUNCTIONAL_CAST; } void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) { VisitCallExpr(E); Writer.AddSourceLocation(E->UDSuffixLoc, Record); Code = serialization::EXPR_USER_DEFINED_LITERAL; } void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_CXX_BOOL_LITERAL; } void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_CXX_NULL_PTR_LITERAL; } void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { VisitExpr(E); Writer.AddSourceRange(E->getSourceRange(), Record); if (E->isTypeOperand()) { Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record); Code = serialization::EXPR_CXX_TYPEID_TYPE; } else { Writer.AddStmt(E->getExprOperand()); Code = serialization::EXPR_CXX_TYPEID_EXPR; } } void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->isImplicit()); Code = serialization::EXPR_CXX_THIS; } void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getThrowLoc(), Record); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->isThrownVariableInScope()); Code = serialization::EXPR_CXX_THROW; } void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { VisitExpr(E); bool HasOtherExprStored = E->Param.getInt(); // Store these first, the reader reads them before creation. Record.push_back(HasOtherExprStored); if (HasOtherExprStored) Writer.AddStmt(E->getExpr()); Writer.AddDeclRef(E->getParam(), Record); Writer.AddSourceLocation(E->getUsedLocation(), Record); Code = serialization::EXPR_CXX_DEFAULT_ARG; } void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getField(), Record); Writer.AddSourceLocation(E->getExprLoc(), Record); Code = serialization::EXPR_CXX_DEFAULT_INIT; } void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { VisitExpr(E); Writer.AddCXXTemporary(E->getTemporary(), Record); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_CXX_BIND_TEMPORARY; } void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { VisitExpr(E); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT; } void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) { VisitExpr(E); Record.push_back(E->isGlobalNew()); Record.push_back(E->isArray()); Record.push_back(E->doesUsualArrayDeleteWantSize()); Record.push_back(E->getNumPlacementArgs()); Record.push_back(E->StoredInitializationStyle); Writer.AddDeclRef(E->getOperatorNew(), Record); Writer.AddDeclRef(E->getOperatorDelete(), Record); Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record); Writer.AddSourceRange(E->getTypeIdParens(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddSourceRange(E->getDirectInitRange(), Record); for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end(); I != e; ++I) Writer.AddStmt(*I); Code = serialization::EXPR_CXX_NEW; } void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { VisitExpr(E); Record.push_back(E->isGlobalDelete()); Record.push_back(E->isArrayForm()); Record.push_back(E->isArrayFormAsWritten()); Record.push_back(E->doesUsualArrayDeleteWantSize()); Writer.AddDeclRef(E->getOperatorDelete(), Record); Writer.AddStmt(E->getArgument()); Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record); Code = serialization::EXPR_CXX_DELETE; } void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Record.push_back(E->isArrow()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record); Writer.AddSourceLocation(E->getColonColonLoc(), Record); Writer.AddSourceLocation(E->getTildeLoc(), Record); // PseudoDestructorTypeStorage. Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record); if (E->getDestroyedTypeIdentifier()) Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record); else Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record); Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR; } void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) { VisitExpr(E); Record.push_back(E->getNumObjects()); for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i) Writer.AddDeclRef(E->getObject(i), Record); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_EXPR_WITH_CLEANUPS; } void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ VisitExpr(E); // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo(); Record.push_back(Args.NumTemplateArgs); AddTemplateKWAndArgsInfo(Args); } if (!E->isImplicitAccess()) Writer.AddStmt(E->getBase()); else Writer.AddStmt(nullptr); Writer.AddTypeRef(E->getBaseType(), Record); Record.push_back(E->isArrow()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record); Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record); Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER; } void ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { VisitExpr(E); // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo(); Record.push_back(Args.NumTemplateArgs); AddTemplateKWAndArgsInfo(Args); } Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddDeclarationNameInfo(E->NameInfo, Record); Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF; } void ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { VisitExpr(E); Record.push_back(E->arg_size()); for (CXXUnresolvedConstructExpr::arg_iterator ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI) Writer.AddStmt(*ArgI); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT; } void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) { VisitExpr(E); // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo(); Record.push_back(Args.NumTemplateArgs); AddTemplateKWAndArgsInfo(Args); } Record.push_back(E->getNumDecls()); for (OverloadExpr::decls_iterator OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) { Writer.AddDeclRef(OvI.getDecl(), Record); Record.push_back(OvI.getAccess()); } Writer.AddDeclarationNameInfo(E->NameInfo, Record); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); } void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { VisitOverloadExpr(E); Record.push_back(E->isArrow()); Record.push_back(E->hasUnresolvedUsing()); Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr); Writer.AddTypeRef(E->getBaseType(), Record); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER; } void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { VisitOverloadExpr(E); Record.push_back(E->requiresADL()); Record.push_back(E->isOverloaded()); Writer.AddDeclRef(E->getNamingClass(), Record); Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP; } void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->TypeTraitExprBits.NumArgs); Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding Record.push_back(E->TypeTraitExprBits.Value); Writer.AddSourceRange(E->getSourceRange(), Record); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) Writer.AddTypeSourceInfo(E->getArg(I), Record); Code = serialization::EXPR_TYPE_TRAIT; } void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->getTrait()); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record); Code = serialization::EXPR_ARRAY_TYPE_TRAIT; } void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { VisitExpr(E); Record.push_back(E->getTrait()); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddStmt(E->getQueriedExpression()); Code = serialization::EXPR_CXX_EXPRESSION_TRAIT; } void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddStmt(E->getOperand()); Code = serialization::EXPR_CXX_NOEXCEPT; } void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getEllipsisLoc(), Record); Record.push_back(E->NumExpansions); Writer.AddStmt(E->getPattern()); Code = serialization::EXPR_PACK_EXPANSION; } void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->OperatorLoc, Record); Writer.AddSourceLocation(E->PackLoc, Record); Writer.AddSourceLocation(E->RParenLoc, Record); Record.push_back(E->Length); Writer.AddDeclRef(E->Pack, Record); Code = serialization::EXPR_SIZEOF_PACK; } void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr( SubstNonTypeTemplateParmExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getParameter(), Record); Writer.AddSourceLocation(E->getNameLoc(), Record); Writer.AddStmt(E->getReplacement()); Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM; } void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getParameterPack(), Record); Writer.AddTemplateArgument(E->getArgumentPack(), Record); Writer.AddSourceLocation(E->getParameterPackLocation(), Record); Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK; } void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { VisitExpr(E); Record.push_back(E->getNumExpansions()); Writer.AddDeclRef(E->getParameterPack(), Record); Writer.AddSourceLocation(E->getParameterPackLocation(), Record); for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end(); I != End; ++I) Writer.AddDeclRef(*I, Record); Code = serialization::EXPR_FUNCTION_PARM_PACK; } void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { VisitExpr(E); Writer.AddStmt(E->getTemporary()); Writer.AddDeclRef(E->getExtendingDecl(), Record); Record.push_back(E->getManglingNumber()); Code = serialization::EXPR_MATERIALIZE_TEMPORARY; } void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSourceExpr()); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_OPAQUE_VALUE; } //===----------------------------------------------------------------------===// // CUDA Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { VisitCallExpr(E); Writer.AddStmt(E->getConfig()); Code = serialization::EXPR_CUDA_KERNEL_CALL; } //===----------------------------------------------------------------------===// // OpenCL Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddStmt(E->getSrcExpr()); Code = serialization::EXPR_ASTYPE; } //===----------------------------------------------------------------------===// // Microsoft Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { VisitExpr(E); Record.push_back(E->isArrow()); Writer.AddStmt(E->getBaseExpr()); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddSourceLocation(E->getMemberLoc(), Record); Writer.AddDeclRef(E->getPropertyDecl(), Record); Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR; } void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) { VisitExpr(E); Writer.AddSourceRange(E->getSourceRange(), Record); if (E->isTypeOperand()) { Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record); Code = serialization::EXPR_CXX_UUIDOF_TYPE; } else { Writer.AddStmt(E->getExprOperand()); Code = serialization::EXPR_CXX_UUIDOF_EXPR; } } void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getExceptLoc(), Record); Writer.AddStmt(S->getFilterExpr()); Writer.AddStmt(S->getBlock()); Code = serialization::STMT_SEH_EXCEPT; } void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getFinallyLoc(), Record); Writer.AddStmt(S->getBlock()); Code = serialization::STMT_SEH_FINALLY; } void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) { VisitStmt(S); Record.push_back(S->getIsCXXTry()); Writer.AddSourceLocation(S->getTryLoc(), Record); Writer.AddStmt(S->getTryBlock()); Writer.AddStmt(S->getHandler()); Code = serialization::STMT_SEH_TRY; } void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getLeaveLoc(), Record); Code = serialization::STMT_SEH_LEAVE; } //===----------------------------------------------------------------------===// // OpenMP Clauses. //===----------------------------------------------------------------------===// namespace clang { class OMPClauseWriter : public OMPClauseVisitor { ASTStmtWriter *Writer; ASTWriter::RecordData &Record; public: OMPClauseWriter(ASTStmtWriter *W, ASTWriter::RecordData &Record) : Writer(W), Record(Record) { } #define OPENMP_CLAUSE(Name, Class) \ void Visit##Class(Class *S); #include "clang/Basic/OpenMPKinds.def" void writeClause(OMPClause *C); }; } void OMPClauseWriter::writeClause(OMPClause *C) { Record.push_back(C->getClauseKind()); Visit(C); Writer->Writer.AddSourceLocation(C->getLocStart(), Record); Writer->Writer.AddSourceLocation(C->getLocEnd(), Record); } void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) { Writer->Writer.AddStmt(C->getCondition()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) { Writer->Writer.AddStmt(C->getCondition()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) { Writer->Writer.AddStmt(C->getNumThreads()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) { Writer->Writer.AddStmt(C->getSafelen()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) { Writer->Writer.AddStmt(C->getNumForLoops()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) { Record.push_back(C->getDefaultKind()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getDefaultKindKwLoc(), Record); } void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) { Record.push_back(C->getProcBindKind()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getProcBindKindKwLoc(), Record); } void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) { Record.push_back(C->getScheduleKind()); Writer->Writer.AddStmt(C->getChunkSize()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getScheduleKindLoc(), Record); Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record); } void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *) {} void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {} void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {} void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {} void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {} void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {} void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *) {} void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {} void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {} void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); Writer->Writer.AddNestedNameSpecifierLoc(C->getQualifierLoc(), Record); Writer->Writer.AddDeclarationNameInfo(C->getNameInfo(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); Writer->Writer.AddStmt(C->getStep()); } void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); Writer->Writer.AddStmt(C->getAlignment()); } void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (auto *VE : C->varlists()) Writer->Writer.AddStmt(VE); } //===----------------------------------------------------------------------===// // OpenMP Directives. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) { Writer.AddSourceLocation(E->getLocStart(), Record); Writer.AddSourceLocation(E->getLocEnd(), Record); OMPClauseWriter ClauseWriter(this, Record); for (unsigned i = 0; i < E->getNumClauses(); ++i) { ClauseWriter.writeClause(E->getClause(i)); } if (E->hasAssociatedStmt()) Writer.AddStmt(E->getAssociatedStmt()); } void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE; } void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); Record.push_back(D->getCollapsedNumber()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_SIMD_DIRECTIVE; } void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); Record.push_back(D->getCollapsedNumber()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE; } void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_SECTION_DIRECTIVE; } void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_SINGLE_DIRECTIVE; } void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_MASTER_DIRECTIVE; } void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Writer.AddDeclarationNameInfo(D->getDirectiveName(), Record); Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE; } void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); Record.push_back(D->getCollapsedNumber()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE; } void ASTStmtWriter::VisitOMPParallelSectionsDirective( OMPParallelSectionsDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE; } void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TASK_DIRECTIVE; } void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE; } void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE; } void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_BARRIER_DIRECTIVE; } void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE; } void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_FLUSH_DIRECTIVE; } void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_ORDERED_DIRECTIVE; } //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) { assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() && "SwitchCase recorded twice"); unsigned NextID = SwitchCaseIDs.size(); SwitchCaseIDs[S] = NextID; return NextID; } unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) { assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() && "SwitchCase hasn't been seen yet"); return SwitchCaseIDs[S]; } void ASTWriter::ClearSwitchCaseIDs() { SwitchCaseIDs.clear(); } /// \brief Write the given substatement or subexpression to the /// bitstream. void ASTWriter::WriteSubStmt(Stmt *S, llvm::DenseMap &SubStmtEntries, llvm::DenseSet &ParentStmts) { RecordData Record; ASTStmtWriter Writer(*this, Record); ++NumStatements; if (!S) { Stream.EmitRecord(serialization::STMT_NULL_PTR, Record); return; } llvm::DenseMap::iterator I = SubStmtEntries.find(S); if (I != SubStmtEntries.end()) { Record.push_back(I->second); Stream.EmitRecord(serialization::STMT_REF_PTR, Record); return; } #ifndef NDEBUG assert(!ParentStmts.count(S) && "There is a Stmt cycle!"); struct ParentStmtInserterRAII { Stmt *S; llvm::DenseSet &ParentStmts; ParentStmtInserterRAII(Stmt *S, llvm::DenseSet &ParentStmts) : S(S), ParentStmts(ParentStmts) { ParentStmts.insert(S); } ~ParentStmtInserterRAII() { ParentStmts.erase(S); } }; ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts); #endif // Redirect ASTWriter::AddStmt to collect sub-stmts. SmallVector SubStmts; CollectedStmts = &SubStmts; Writer.Code = serialization::STMT_NULL_PTR; Writer.AbbrevToUse = 0; Writer.Visit(S); #ifndef NDEBUG if (Writer.Code == serialization::STMT_NULL_PTR) { SourceManager &SrcMgr = DeclIDs.begin()->first->getASTContext().getSourceManager(); S->dump(SrcMgr); llvm_unreachable("Unhandled sub-statement writing AST file"); } #endif // Revert ASTWriter::AddStmt. CollectedStmts = &StmtsToEmit; // Write the sub-stmts in reverse order, last to first. When reading them back // we will read them in correct order by "pop"ing them from the Stmts stack. // This simplifies reading and allows to store a variable number of sub-stmts // without knowing it in advance. while (!SubStmts.empty()) WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts); Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse); SubStmtEntries[S] = Stream.GetCurrentBitNo(); } /// \brief Flush all of the statements that have been added to the /// queue via AddStmt(). void ASTWriter::FlushStmts() { RecordData Record; // We expect to be the only consumer of the two temporary statement maps, // assert that they are empty. assert(SubStmtEntries.empty() && "unexpected entries in sub-stmt map"); assert(ParentStmts.empty() && "unexpected entries in parent stmt map"); for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts); assert(N == StmtsToEmit.size() && "Substatement written via AddStmt rather than WriteSubStmt!"); // Note that we are at the end of a full expression. Any // expression records that follow this one are part of a different // expression. Stream.EmitRecord(serialization::STMT_STOP, Record); SubStmtEntries.clear(); ParentStmts.clear(); } StmtsToEmit.clear(); } @ 1.1.1.3.4.1 log @file ASTWriterStmt.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:30 +0000 @ text @d1 1868 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1868 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief Implements serialization for Statements and Expressions. /// //===----------------------------------------------------------------------===// #include "clang/Serialization/ASTWriter.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/StmtVisitor.h" #include "clang/Lex/Token.h" #include "llvm/Bitcode/BitstreamWriter.h" using namespace clang; //===----------------------------------------------------------------------===// // Statement/expression serialization //===----------------------------------------------------------------------===// namespace clang { class ASTStmtWriter : public StmtVisitor { friend class OMPClauseWriter; ASTWriter &Writer; ASTWriter::RecordData &Record; public: serialization::StmtCode Code; unsigned AbbrevToUse; ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record) : Writer(Writer), Record(Record) { } void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &Args); void VisitStmt(Stmt *S); #define STMT(Type, Base) \ void Visit##Type(Type *); #include "clang/AST/StmtNodes.inc" }; } void ASTStmtWriter:: AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &Args) { Writer.AddSourceLocation(Args.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(Args.LAngleLoc, Record); Writer.AddSourceLocation(Args.RAngleLoc, Record); for (unsigned i=0; i != Args.NumTemplateArgs; ++i) Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record); } void ASTStmtWriter::VisitStmt(Stmt *S) { } void ASTStmtWriter::VisitNullStmt(NullStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getSemiLoc(), Record); Record.push_back(S->HasLeadingEmptyMacro); Code = serialization::STMT_NULL; } void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) { VisitStmt(S); Record.push_back(S->size()); for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end(); CS != CSEnd; ++CS) Writer.AddStmt(*CS); Writer.AddSourceLocation(S->getLBracLoc(), Record); Writer.AddSourceLocation(S->getRBracLoc(), Record); Code = serialization::STMT_COMPOUND; } void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) { VisitStmt(S); Record.push_back(Writer.getSwitchCaseID(S)); Writer.AddSourceLocation(S->getKeywordLoc(), Record); Writer.AddSourceLocation(S->getColonLoc(), Record); } void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) { VisitSwitchCase(S); Writer.AddStmt(S->getLHS()); Writer.AddStmt(S->getRHS()); Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getEllipsisLoc(), Record); Code = serialization::STMT_CASE; } void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) { VisitSwitchCase(S); Writer.AddStmt(S->getSubStmt()); Code = serialization::STMT_DEFAULT; } void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getDecl(), Record); Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getIdentLoc(), Record); Code = serialization::STMT_LABEL; } void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) { VisitStmt(S); Record.push_back(S->getAttrs().size()); Writer.WriteAttributes(S->getAttrs(), Record); Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getAttrLoc(), Record); Code = serialization::STMT_ATTRIBUTED; } void ASTStmtWriter::VisitIfStmt(IfStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getThen()); Writer.AddStmt(S->getElse()); Writer.AddSourceLocation(S->getIfLoc(), Record); Writer.AddSourceLocation(S->getElseLoc(), Record); Code = serialization::STMT_IF; } void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getSwitchLoc(), Record); Record.push_back(S->isAllEnumCasesCovered()); for (SwitchCase *SC = S->getSwitchCaseList(); SC; SC = SC->getNextSwitchCase()) Record.push_back(Writer.RecordSwitchCaseID(SC)); Code = serialization::STMT_SWITCH; } void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getWhileLoc(), Record); Code = serialization::STMT_WHILE; } void ASTStmtWriter::VisitDoStmt(DoStmt *S) { VisitStmt(S); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getDoLoc(), Record); Writer.AddSourceLocation(S->getWhileLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_DO; } void ASTStmtWriter::VisitForStmt(ForStmt *S) { VisitStmt(S); Writer.AddStmt(S->getInit()); Writer.AddStmt(S->getCond()); Writer.AddDeclRef(S->getConditionVariable(), Record); Writer.AddStmt(S->getInc()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getLParenLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_FOR; } void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getLabel(), Record); Writer.AddSourceLocation(S->getGotoLoc(), Record); Writer.AddSourceLocation(S->getLabelLoc(), Record); Code = serialization::STMT_GOTO; } void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getGotoLoc(), Record); Writer.AddSourceLocation(S->getStarLoc(), Record); Writer.AddStmt(S->getTarget()); Code = serialization::STMT_INDIRECT_GOTO; } void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getContinueLoc(), Record); Code = serialization::STMT_CONTINUE; } void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getBreakLoc(), Record); Code = serialization::STMT_BREAK; } void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) { VisitStmt(S); Writer.AddStmt(S->getRetValue()); Writer.AddSourceLocation(S->getReturnLoc(), Record); Writer.AddDeclRef(S->getNRVOCandidate(), Record); Code = serialization::STMT_RETURN; } void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getStartLoc(), Record); Writer.AddSourceLocation(S->getEndLoc(), Record); DeclGroupRef DG = S->getDeclGroup(); for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D) Writer.AddDeclRef(*D, Record); Code = serialization::STMT_DECL; } void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) { VisitStmt(S); Record.push_back(S->getNumOutputs()); Record.push_back(S->getNumInputs()); Record.push_back(S->getNumClobbers()); Writer.AddSourceLocation(S->getAsmLoc(), Record); Record.push_back(S->isVolatile()); Record.push_back(S->isSimple()); } void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) { VisitAsmStmt(S); Writer.AddSourceLocation(S->getRParenLoc(), Record); Writer.AddStmt(S->getAsmString()); // Outputs for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record); Writer.AddStmt(S->getOutputConstraintLiteral(I)); Writer.AddStmt(S->getOutputExpr(I)); } // Inputs for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { Writer.AddIdentifierRef(S->getInputIdentifier(I), Record); Writer.AddStmt(S->getInputConstraintLiteral(I)); Writer.AddStmt(S->getInputExpr(I)); } // Clobbers for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) Writer.AddStmt(S->getClobberStringLiteral(I)); Code = serialization::STMT_GCCASM; } void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) { VisitAsmStmt(S); Writer.AddSourceLocation(S->getLBraceLoc(), Record); Writer.AddSourceLocation(S->getEndLoc(), Record); Record.push_back(S->getNumAsmToks()); Writer.AddString(S->getAsmString(), Record); // Tokens for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) { Writer.AddToken(S->getAsmToks()[I], Record); } // Clobbers for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) { Writer.AddString(S->getClobber(I), Record); } // Outputs for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { Writer.AddStmt(S->getOutputExpr(I)); Writer.AddString(S->getOutputConstraint(I), Record); } // Inputs for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { Writer.AddStmt(S->getInputExpr(I)); Writer.AddString(S->getInputConstraint(I), Record); } Code = serialization::STMT_MSASM; } void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) { VisitStmt(S); // NumCaptures Record.push_back(std::distance(S->capture_begin(), S->capture_end())); // CapturedDecl and captured region kind Writer.AddDeclRef(S->getCapturedDecl(), Record); Record.push_back(S->getCapturedRegionKind()); Writer.AddDeclRef(S->getCapturedRecordDecl(), Record); // Capture inits for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(), E = S->capture_init_end(); I != E; ++I) Writer.AddStmt(*I); // Body Writer.AddStmt(S->getCapturedStmt()); // Captures for (CapturedStmt::capture_iterator I = S->capture_begin(), E = S->capture_end(); I != E; ++I) { if (I->capturesThis()) Writer.AddDeclRef(0, Record); else Writer.AddDeclRef(I->getCapturedVar(), Record); Record.push_back(I->getCaptureKind()); Writer.AddSourceLocation(I->getLocation(), Record); } Code = serialization::STMT_CAPTURED; } void ASTStmtWriter::VisitExpr(Expr *E) { VisitStmt(E); Writer.AddTypeRef(E->getType(), Record); Record.push_back(E->isTypeDependent()); Record.push_back(E->isValueDependent()); Record.push_back(E->isInstantiationDependent()); Record.push_back(E->containsUnexpandedParameterPack()); Record.push_back(E->getValueKind()); Record.push_back(E->getObjectKind()); } void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->getIdentType()); // FIXME: stable encoding Code = serialization::EXPR_PREDEFINED; } void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) { VisitExpr(E); Record.push_back(E->hasQualifier()); Record.push_back(E->getDecl() != E->getFoundDecl()); Record.push_back(E->hasTemplateKWAndArgsInfo()); Record.push_back(E->hadMultipleCandidates()); Record.push_back(E->refersToEnclosingLocal()); if (E->hasTemplateKWAndArgsInfo()) { unsigned NumTemplateArgs = E->getNumTemplateArgs(); Record.push_back(NumTemplateArgs); } DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind()); if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) && (E->getDecl() == E->getFoundDecl()) && nk == DeclarationName::Identifier) { AbbrevToUse = Writer.getDeclRefExprAbbrev(); } if (E->hasQualifier()) Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); if (E->getDecl() != E->getFoundDecl()) Writer.AddDeclRef(E->getFoundDecl(), Record); if (E->hasTemplateKWAndArgsInfo()) AddTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo()); Writer.AddDeclRef(E->getDecl(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record); Code = serialization::EXPR_DECL_REF; } void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddAPInt(E->getValue(), Record); if (E->getValue().getBitWidth() == 32) { AbbrevToUse = Writer.getIntegerLiteralAbbrev(); } Code = serialization::EXPR_INTEGER_LITERAL; } void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) { VisitExpr(E); Record.push_back(E->getRawSemantics()); Record.push_back(E->isExact()); Writer.AddAPFloat(E->getValue(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_FLOATING_LITERAL; } void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_IMAGINARY_LITERAL; } void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) { VisitExpr(E); Record.push_back(E->getByteLength()); Record.push_back(E->getNumConcatenated()); Record.push_back(E->getKind()); Record.push_back(E->isPascal()); // FIXME: String data should be stored as a blob at the end of the // StringLiteral. However, we can't do so now because we have no // provision for coping with abbreviations when we're jumping around // the AST file during deserialization. Record.append(E->getBytes().begin(), E->getBytes().end()); for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I) Writer.AddSourceLocation(E->getStrTokenLoc(I), Record); Code = serialization::EXPR_STRING_LITERAL; } void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->getKind()); AbbrevToUse = Writer.getCharacterLiteralAbbrev(); Code = serialization::EXPR_CHARACTER_LITERAL; } void ASTStmtWriter::VisitParenExpr(ParenExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParen(), Record); Writer.AddSourceLocation(E->getRParen(), Record); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_PAREN; } void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) { VisitExpr(E); Record.push_back(E->NumExprs); for (unsigned i=0; i != E->NumExprs; ++i) Writer.AddStmt(E->Exprs[i]); Writer.AddSourceLocation(E->LParenLoc, Record); Writer.AddSourceLocation(E->RParenLoc, Record); Code = serialization::EXPR_PAREN_LIST; } void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = serialization::EXPR_UNARY_OPERATOR; } void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) { VisitExpr(E); Record.push_back(E->getNumComponents()); Record.push_back(E->getNumExpressions()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { const OffsetOfExpr::OffsetOfNode &ON = E->getComponent(I); Record.push_back(ON.getKind()); // FIXME: Stable encoding Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record); Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record); switch (ON.getKind()) { case OffsetOfExpr::OffsetOfNode::Array: Record.push_back(ON.getArrayExprIndex()); break; case OffsetOfExpr::OffsetOfNode::Field: Writer.AddDeclRef(ON.getField(), Record); break; case OffsetOfExpr::OffsetOfNode::Identifier: Writer.AddIdentifierRef(ON.getFieldName(), Record); break; case OffsetOfExpr::OffsetOfNode::Base: Writer.AddCXXBaseSpecifier(*ON.getBase(), Record); break; } } for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) Writer.AddStmt(E->getIndexExpr(I)); Code = serialization::EXPR_OFFSETOF; } void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->getKind()); if (E->isArgumentType()) Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record); else { Record.push_back(0); Writer.AddStmt(E->getArgumentExpr()); } Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_SIZEOF_ALIGN_OF; } void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { VisitExpr(E); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getRBracketLoc(), Record); Code = serialization::EXPR_ARRAY_SUBSCRIPT; } void ASTStmtWriter::VisitCallExpr(CallExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddStmt(E->getCallee()); for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) Writer.AddStmt(*Arg); Code = serialization::EXPR_CALL; } void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) { // Don't call VisitExpr, we'll write everything here. Record.push_back(E->hasQualifier()); if (E->hasQualifier()) Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { Writer.AddSourceLocation(E->getTemplateKeywordLoc(), Record); unsigned NumTemplateArgs = E->getNumTemplateArgs(); Record.push_back(NumTemplateArgs); Writer.AddSourceLocation(E->getLAngleLoc(), Record); Writer.AddSourceLocation(E->getRAngleLoc(), Record); for (unsigned i=0; i != NumTemplateArgs; ++i) Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record); } Record.push_back(E->hadMultipleCandidates()); DeclAccessPair FoundDecl = E->getFoundDecl(); Writer.AddDeclRef(FoundDecl.getDecl(), Record); Record.push_back(FoundDecl.getAccess()); Writer.AddTypeRef(E->getType(), Record); Record.push_back(E->getValueKind()); Record.push_back(E->getObjectKind()); Writer.AddStmt(E->getBase()); Writer.AddDeclRef(E->getMemberDecl(), Record); Writer.AddSourceLocation(E->getMemberLoc(), Record); Record.push_back(E->isArrow()); Writer.AddDeclarationNameLoc(E->MemberDNLoc, E->getMemberDecl()->getDeclName(), Record); Code = serialization::EXPR_MEMBER; } void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Writer.AddSourceLocation(E->getIsaMemberLoc(), Record); Writer.AddSourceLocation(E->getOpLoc(), Record); Record.push_back(E->isArrow()); Code = serialization::EXPR_OBJC_ISA; } void ASTStmtWriter:: VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->shouldCopy()); Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE; } void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getBridgeKeywordLoc(), Record); Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding Code = serialization::EXPR_OBJC_BRIDGED_CAST; } void ASTStmtWriter::VisitCastExpr(CastExpr *E) { VisitExpr(E); Record.push_back(E->path_size()); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->getCastKind()); // FIXME: stable encoding for (CastExpr::path_iterator PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI) Writer.AddCXXBaseSpecifier(**PI, Record); } void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) { VisitExpr(E); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Record.push_back(E->isFPContractable()); Code = serialization::EXPR_BINARY_OPERATOR; } void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { VisitBinaryOperator(E); Writer.AddTypeRef(E->getComputationLHSType(), Record); Writer.AddTypeRef(E->getComputationResultType(), Record); Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR; } void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) { VisitExpr(E); Writer.AddStmt(E->getCond()); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getQuestionLoc(), Record); Writer.AddSourceLocation(E->getColonLoc(), Record); Code = serialization::EXPR_CONDITIONAL_OPERATOR; } void ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { VisitExpr(E); Writer.AddStmt(E->getOpaqueValue()); Writer.AddStmt(E->getCommon()); Writer.AddStmt(E->getCond()); Writer.AddStmt(E->getTrueExpr()); Writer.AddStmt(E->getFalseExpr()); Writer.AddSourceLocation(E->getQuestionLoc(), Record); Writer.AddSourceLocation(E->getColonLoc(), Record); Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR; } void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) { VisitCastExpr(E); Code = serialization::EXPR_IMPLICIT_CAST; } void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) { VisitCastExpr(E); Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record); } void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CSTYLE_CAST; } void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddStmt(E->getInitializer()); Record.push_back(E->isFileScope()); Code = serialization::EXPR_COMPOUND_LITERAL; } void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Writer.AddIdentifierRef(&E->getAccessor(), Record); Writer.AddSourceLocation(E->getAccessorLoc(), Record); Code = serialization::EXPR_EXT_VECTOR_ELEMENT; } void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) { VisitExpr(E); // NOTE: only add the (possibly null) syntactic form. // No need to serialize the isSemanticForm flag and the semantic form. Writer.AddStmt(E->getSyntacticForm()); Writer.AddSourceLocation(E->getLBraceLoc(), Record); Writer.AddSourceLocation(E->getRBraceLoc(), Record); bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is(); Record.push_back(isArrayFiller); if (isArrayFiller) Writer.AddStmt(E->getArrayFiller()); else Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record); Record.push_back(E->hadArrayRangeDesignator()); Record.push_back(E->getNumInits()); if (isArrayFiller) { // ArrayFiller may have filled "holes" due to designated initializer. // Replace them by 0 to indicate that the filler goes in that place. Expr *filler = E->getArrayFiller(); for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : 0); } else { for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) Writer.AddStmt(E->getInit(I)); } Code = serialization::EXPR_INIT_LIST; } void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) Writer.AddStmt(E->getSubExpr(I)); Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record); Record.push_back(E->usesGNUSyntax()); for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), DEnd = E->designators_end(); D != DEnd; ++D) { if (D->isFieldDesignator()) { if (FieldDecl *Field = D->getField()) { Record.push_back(serialization::DESIG_FIELD_DECL); Writer.AddDeclRef(Field, Record); } else { Record.push_back(serialization::DESIG_FIELD_NAME); Writer.AddIdentifierRef(D->getFieldName(), Record); } Writer.AddSourceLocation(D->getDotLoc(), Record); Writer.AddSourceLocation(D->getFieldLoc(), Record); } else if (D->isArrayDesignator()) { Record.push_back(serialization::DESIG_ARRAY); Record.push_back(D->getFirstExprIndex()); Writer.AddSourceLocation(D->getLBracketLoc(), Record); Writer.AddSourceLocation(D->getRBracketLoc(), Record); } else { assert(D->isArrayRangeDesignator() && "Unknown designator"); Record.push_back(serialization::DESIG_ARRAY_RANGE); Record.push_back(D->getFirstExprIndex()); Writer.AddSourceLocation(D->getLBracketLoc(), Record); Writer.AddSourceLocation(D->getEllipsisLoc(), Record); Writer.AddSourceLocation(D->getRBracketLoc(), Record); } } Code = serialization::EXPR_DESIGNATED_INIT; } void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { VisitExpr(E); Code = serialization::EXPR_IMPLICIT_VALUE_INIT; } void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_VA_ARG; } void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getAmpAmpLoc(), Record); Writer.AddSourceLocation(E->getLabelLoc(), Record); Writer.AddDeclRef(E->getLabel(), Record); Code = serialization::EXPR_ADDR_LABEL; } void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubStmt()); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_STMT; } void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) { VisitExpr(E); Writer.AddStmt(E->getCond()); Writer.AddStmt(E->getLHS()); Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue()); Code = serialization::EXPR_CHOOSE; } void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getTokenLocation(), Record); Code = serialization::EXPR_GNU_NULL; } void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) Writer.AddStmt(E->getExpr(I)); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_SHUFFLE_VECTOR; } void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddStmt(E->getSrcExpr()); Code = serialization::EXPR_CONVERT_VECTOR; } void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getBlockDecl(), Record); Code = serialization::EXPR_BLOCK; } void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) { VisitExpr(E); Record.push_back(E->getNumAssocs()); Writer.AddStmt(E->getControllingExpr()); for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) { Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record); Writer.AddStmt(E->getAssocExpr(I)); } Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex()); Writer.AddSourceLocation(E->getGenericLoc(), Record); Writer.AddSourceLocation(E->getDefaultLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_GENERIC_SELECTION; } void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) { VisitExpr(E); Record.push_back(E->getNumSemanticExprs()); // Push the result index. Currently, this needs to exactly match // the encoding used internally for ResultIndex. unsigned result = E->getResultExprIndex(); result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1); Record.push_back(result); Writer.AddStmt(E->getSyntacticForm()); for (PseudoObjectExpr::semantics_iterator i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) { Writer.AddStmt(*i); } Code = serialization::EXPR_PSEUDO_OBJECT; } void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) { VisitExpr(E); Record.push_back(E->getOp()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) Writer.AddStmt(E->getSubExprs()[I]); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_ATOMIC; } //===----------------------------------------------------------------------===// // Objective-C Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) { VisitExpr(E); Writer.AddStmt(E->getString()); Writer.AddSourceLocation(E->getAtLoc(), Record); Code = serialization::EXPR_OBJC_STRING_LITERAL; } void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Writer.AddDeclRef(E->getBoxingMethod(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Code = serialization::EXPR_OBJC_BOXED_EXPRESSION; } void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { VisitExpr(E); Record.push_back(E->getNumElements()); for (unsigned i = 0; i < E->getNumElements(); i++) Writer.AddStmt(E->getElement(i)); Writer.AddDeclRef(E->getArrayWithObjectsMethod(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Code = serialization::EXPR_OBJC_ARRAY_LITERAL; } void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { VisitExpr(E); Record.push_back(E->getNumElements()); Record.push_back(E->HasPackExpansions); for (unsigned i = 0; i < E->getNumElements(); i++) { ObjCDictionaryElement Element = E->getKeyValueElement(i); Writer.AddStmt(Element.Key); Writer.AddStmt(Element.Value); if (E->HasPackExpansions) { Writer.AddSourceLocation(Element.EllipsisLoc, Record); unsigned NumExpansions = 0; if (Element.NumExpansions) NumExpansions = *Element.NumExpansions + 1; Record.push_back(NumExpansions); } } Writer.AddDeclRef(E->getDictWithObjectsMethod(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL; } void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { VisitExpr(E); Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_OBJC_ENCODE; } void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { VisitExpr(E); Writer.AddSelectorRef(E->getSelector(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_OBJC_SELECTOR_EXPR; } void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getProtocol(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); Writer.AddSourceLocation(E->ProtoLoc, Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_OBJC_PROTOCOL_EXPR; } void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getDecl(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddSourceLocation(E->getOpLoc(), Record); Writer.AddStmt(E->getBase()); Record.push_back(E->isArrow()); Record.push_back(E->isFreeIvar()); Code = serialization::EXPR_OBJC_IVAR_REF_EXPR; } void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { VisitExpr(E); Record.push_back(E->SetterAndMethodRefFlags.getInt()); Record.push_back(E->isImplicitProperty()); if (E->isImplicitProperty()) { Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record); Writer.AddDeclRef(E->getImplicitPropertySetter(), Record); } else { Writer.AddDeclRef(E->getExplicitProperty(), Record); } Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddSourceLocation(E->getReceiverLocation(), Record); if (E->isObjectReceiver()) { Record.push_back(0); Writer.AddStmt(E->getBase()); } else if (E->isSuperReceiver()) { Record.push_back(1); Writer.AddTypeRef(E->getSuperReceiverType(), Record); } else { Record.push_back(2); Writer.AddDeclRef(E->getClassReceiver(), Record); } Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR; } void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getRBracket(), Record); Writer.AddStmt(E->getBaseExpr()); Writer.AddStmt(E->getKeyExpr()); Writer.AddDeclRef(E->getAtIndexMethodDecl(), Record); Writer.AddDeclRef(E->setAtIndexMethodDecl(), Record); Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR; } void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); Record.push_back(E->getNumStoredSelLocs()); Record.push_back(E->SelLocsKind); Record.push_back(E->isDelegateInitCall()); Record.push_back(E->IsImplicit); Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding switch (E->getReceiverKind()) { case ObjCMessageExpr::Instance: Writer.AddStmt(E->getInstanceReceiver()); break; case ObjCMessageExpr::Class: Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record); break; case ObjCMessageExpr::SuperClass: case ObjCMessageExpr::SuperInstance: Writer.AddTypeRef(E->getSuperType(), Record); Writer.AddSourceLocation(E->getSuperLoc(), Record); break; } if (E->getMethodDecl()) { Record.push_back(1); Writer.AddDeclRef(E->getMethodDecl(), Record); } else { Record.push_back(0); Writer.AddSelectorRef(E->getSelector(), Record); } Writer.AddSourceLocation(E->getLeftLoc(), Record); Writer.AddSourceLocation(E->getRightLoc(), Record); for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) Writer.AddStmt(*Arg); SourceLocation *Locs = E->getStoredSelLocs(); for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i) Writer.AddSourceLocation(Locs[i], Record); Code = serialization::EXPR_OBJC_MESSAGE_EXPR; } void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { VisitStmt(S); Writer.AddStmt(S->getElement()); Writer.AddStmt(S->getCollection()); Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_OBJC_FOR_COLLECTION; } void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { Writer.AddStmt(S->getCatchBody()); Writer.AddDeclRef(S->getCatchParamDecl(), Record); Writer.AddSourceLocation(S->getAtCatchLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = serialization::STMT_OBJC_CATCH; } void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { Writer.AddStmt(S->getFinallyBody()); Writer.AddSourceLocation(S->getAtFinallyLoc(), Record); Code = serialization::STMT_OBJC_FINALLY; } void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getAtLoc(), Record); Code = serialization::STMT_OBJC_AUTORELEASE_POOL; } void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { Record.push_back(S->getNumCatchStmts()); Record.push_back(S->getFinallyStmt() != 0); Writer.AddStmt(S->getTryBody()); for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) Writer.AddStmt(S->getCatchStmt(I)); if (S->getFinallyStmt()) Writer.AddStmt(S->getFinallyStmt()); Writer.AddSourceLocation(S->getAtTryLoc(), Record); Code = serialization::STMT_OBJC_AT_TRY; } void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { Writer.AddStmt(S->getSynchExpr()); Writer.AddStmt(S->getSynchBody()); Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record); Code = serialization::STMT_OBJC_AT_SYNCHRONIZED; } void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { Writer.AddStmt(S->getThrowExpr()); Writer.AddSourceLocation(S->getThrowLoc(), Record); Code = serialization::STMT_OBJC_AT_THROW; } void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_OBJC_BOOL_LITERAL; } //===----------------------------------------------------------------------===// // C++ Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getCatchLoc(), Record); Writer.AddDeclRef(S->getExceptionDecl(), Record); Writer.AddStmt(S->getHandlerBlock()); Code = serialization::STMT_CXX_CATCH; } void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) { VisitStmt(S); Record.push_back(S->getNumHandlers()); Writer.AddSourceLocation(S->getTryLoc(), Record); Writer.AddStmt(S->getTryBlock()); for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) Writer.AddStmt(S->getHandler(i)); Code = serialization::STMT_CXX_TRY; } void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getColonLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Writer.AddStmt(S->getRangeStmt()); Writer.AddStmt(S->getBeginEndStmt()); Writer.AddStmt(S->getCond()); Writer.AddStmt(S->getInc()); Writer.AddStmt(S->getLoopVarStmt()); Writer.AddStmt(S->getBody()); Code = serialization::STMT_CXX_FOR_RANGE; } void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getKeywordLoc(), Record); Record.push_back(S->isIfExists()); Writer.AddNestedNameSpecifierLoc(S->getQualifierLoc(), Record); Writer.AddDeclarationNameInfo(S->getNameInfo(), Record); Writer.AddStmt(S->getSubStmt()); Code = serialization::STMT_MS_DEPENDENT_EXISTS; } void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { VisitCallExpr(E); Record.push_back(E->getOperator()); Writer.AddSourceRange(E->Range, Record); Record.push_back(E->isFPContractable()); Code = serialization::EXPR_CXX_OPERATOR_CALL; } void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { VisitCallExpr(E); Code = serialization::EXPR_CXX_MEMBER_CALL; } void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) Writer.AddStmt(E->getArg(I)); Writer.AddDeclRef(E->getConstructor(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->isElidable()); Record.push_back(E->hadMultipleCandidates()); Record.push_back(E->isListInitialization()); Record.push_back(E->requiresZeroInitialization()); Record.push_back(E->getConstructionKind()); // FIXME: stable encoding Writer.AddSourceRange(E->getParenOrBraceRange(), Record); Code = serialization::EXPR_CXX_CONSTRUCT; } void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { VisitCXXConstructExpr(E); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Code = serialization::EXPR_CXX_TEMPORARY_OBJECT; } void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) { VisitExpr(E); Record.push_back(E->NumCaptures); unsigned NumArrayIndexVars = 0; if (E->HasArrayIndexVars) NumArrayIndexVars = E->getArrayIndexStarts()[E->NumCaptures]; Record.push_back(NumArrayIndexVars); Writer.AddSourceRange(E->IntroducerRange, Record); Record.push_back(E->CaptureDefault); // FIXME: stable encoding Writer.AddSourceLocation(E->CaptureDefaultLoc, Record); Record.push_back(E->ExplicitParams); Record.push_back(E->ExplicitResultType); Writer.AddSourceLocation(E->ClosingBrace, Record); // Add capture initializers. for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), CEnd = E->capture_init_end(); C != CEnd; ++C) { Writer.AddStmt(*C); } // Add array index variables, if any. if (NumArrayIndexVars) { Record.append(E->getArrayIndexStarts(), E->getArrayIndexStarts() + E->NumCaptures + 1); VarDecl **ArrayIndexVars = E->getArrayIndexVars(); for (unsigned I = 0; I != NumArrayIndexVars; ++I) Writer.AddDeclRef(ArrayIndexVars[I], Record); } Code = serialization::EXPR_LAMBDA; } void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST; } void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()), Record); Writer.AddSourceRange(E->getAngleBrackets(), Record); } void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_STATIC_CAST; } void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_DYNAMIC_CAST; } void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_REINTERPRET_CAST; } void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) { VisitCXXNamedCastExpr(E); Code = serialization::EXPR_CXX_CONST_CAST; } void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { VisitExplicitCastExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CXX_FUNCTIONAL_CAST; } void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) { VisitCallExpr(E); Writer.AddSourceLocation(E->UDSuffixLoc, Record); Code = serialization::EXPR_USER_DEFINED_LITERAL; } void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_CXX_BOOL_LITERAL; } void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_CXX_NULL_PTR_LITERAL; } void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { VisitExpr(E); Writer.AddSourceRange(E->getSourceRange(), Record); if (E->isTypeOperand()) { Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record); Code = serialization::EXPR_CXX_TYPEID_TYPE; } else { Writer.AddStmt(E->getExprOperand()); Code = serialization::EXPR_CXX_TYPEID_EXPR; } } void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->isImplicit()); Code = serialization::EXPR_CXX_THIS; } void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getThrowLoc(), Record); Writer.AddStmt(E->getSubExpr()); Record.push_back(E->isThrownVariableInScope()); Code = serialization::EXPR_CXX_THROW; } void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { VisitExpr(E); bool HasOtherExprStored = E->Param.getInt(); // Store these first, the reader reads them before creation. Record.push_back(HasOtherExprStored); if (HasOtherExprStored) Writer.AddStmt(E->getExpr()); Writer.AddDeclRef(E->getParam(), Record); Writer.AddSourceLocation(E->getUsedLocation(), Record); Code = serialization::EXPR_CXX_DEFAULT_ARG; } void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getField(), Record); Writer.AddSourceLocation(E->getExprLoc(), Record); Code = serialization::EXPR_CXX_DEFAULT_INIT; } void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { VisitExpr(E); Writer.AddCXXTemporary(E->getTemporary(), Record); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_CXX_BIND_TEMPORARY; } void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { VisitExpr(E); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT; } void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) { VisitExpr(E); Record.push_back(E->isGlobalNew()); Record.push_back(E->isArray()); Record.push_back(E->doesUsualArrayDeleteWantSize()); Record.push_back(E->getNumPlacementArgs()); Record.push_back(E->StoredInitializationStyle); Writer.AddDeclRef(E->getOperatorNew(), Record); Writer.AddDeclRef(E->getOperatorDelete(), Record); Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record); Writer.AddSourceRange(E->getTypeIdParens(), Record); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddSourceRange(E->getDirectInitRange(), Record); for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end(); I != e; ++I) Writer.AddStmt(*I); Code = serialization::EXPR_CXX_NEW; } void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { VisitExpr(E); Record.push_back(E->isGlobalDelete()); Record.push_back(E->isArrayForm()); Record.push_back(E->isArrayFormAsWritten()); Record.push_back(E->doesUsualArrayDeleteWantSize()); Writer.AddDeclRef(E->getOperatorDelete(), Record); Writer.AddStmt(E->getArgument()); Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record); Code = serialization::EXPR_CXX_DELETE; } void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { VisitExpr(E); Writer.AddStmt(E->getBase()); Record.push_back(E->isArrow()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record); Writer.AddSourceLocation(E->getColonColonLoc(), Record); Writer.AddSourceLocation(E->getTildeLoc(), Record); // PseudoDestructorTypeStorage. Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record); if (E->getDestroyedTypeIdentifier()) Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record); else Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record); Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR; } void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) { VisitExpr(E); Record.push_back(E->getNumObjects()); for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i) Writer.AddDeclRef(E->getObject(i), Record); Writer.AddStmt(E->getSubExpr()); Code = serialization::EXPR_EXPR_WITH_CLEANUPS; } void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ VisitExpr(E); // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo(); Record.push_back(Args.NumTemplateArgs); AddTemplateKWAndArgsInfo(Args); } if (!E->isImplicitAccess()) Writer.AddStmt(E->getBase()); else Writer.AddStmt(0); Writer.AddTypeRef(E->getBaseType(), Record); Record.push_back(E->isArrow()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record); Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record); Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER; } void ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { VisitExpr(E); // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo(); Record.push_back(Args.NumTemplateArgs); AddTemplateKWAndArgsInfo(Args); } Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddDeclarationNameInfo(E->NameInfo, Record); Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF; } void ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { VisitExpr(E); Record.push_back(E->arg_size()); for (CXXUnresolvedConstructExpr::arg_iterator ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI) Writer.AddStmt(*ArgI); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT; } void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) { VisitExpr(E); // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. Record.push_back(E->HasTemplateKWAndArgsInfo); if (E->HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo(); Record.push_back(Args.NumTemplateArgs); AddTemplateKWAndArgsInfo(Args); } Record.push_back(E->getNumDecls()); for (OverloadExpr::decls_iterator OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) { Writer.AddDeclRef(OvI.getDecl(), Record); Record.push_back(OvI.getAccess()); } Writer.AddDeclarationNameInfo(E->NameInfo, Record); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); } void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { VisitOverloadExpr(E); Record.push_back(E->isArrow()); Record.push_back(E->hasUnresolvedUsing()); Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : 0); Writer.AddTypeRef(E->getBaseType(), Record); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER; } void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { VisitOverloadExpr(E); Record.push_back(E->requiresADL()); Record.push_back(E->isOverloaded()); Writer.AddDeclRef(E->getNamingClass(), Record); Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP; } void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->TypeTraitExprBits.NumArgs); Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding Record.push_back(E->TypeTraitExprBits.Value); Writer.AddSourceRange(E->getSourceRange(), Record); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) Writer.AddTypeSourceInfo(E->getArg(I), Record); Code = serialization::EXPR_TYPE_TRAIT; } void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { VisitExpr(E); Record.push_back(E->getTrait()); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record); Code = serialization::EXPR_ARRAY_TYPE_TRAIT; } void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { VisitExpr(E); Record.push_back(E->getTrait()); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddStmt(E->getQueriedExpression()); Code = serialization::EXPR_CXX_EXPRESSION_TRAIT; } void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { VisitExpr(E); Record.push_back(E->getValue()); Writer.AddSourceRange(E->getSourceRange(), Record); Writer.AddStmt(E->getOperand()); Code = serialization::EXPR_CXX_NOEXCEPT; } void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getEllipsisLoc(), Record); Record.push_back(E->NumExpansions); Writer.AddStmt(E->getPattern()); Code = serialization::EXPR_PACK_EXPANSION; } void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->OperatorLoc, Record); Writer.AddSourceLocation(E->PackLoc, Record); Writer.AddSourceLocation(E->RParenLoc, Record); Record.push_back(E->Length); Writer.AddDeclRef(E->Pack, Record); Code = serialization::EXPR_SIZEOF_PACK; } void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr( SubstNonTypeTemplateParmExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getParameter(), Record); Writer.AddSourceLocation(E->getNameLoc(), Record); Writer.AddStmt(E->getReplacement()); Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM; } void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getParameterPack(), Record); Writer.AddTemplateArgument(E->getArgumentPack(), Record); Writer.AddSourceLocation(E->getParameterPackLocation(), Record); Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK; } void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { VisitExpr(E); Record.push_back(E->getNumExpansions()); Writer.AddDeclRef(E->getParameterPack(), Record); Writer.AddSourceLocation(E->getParameterPackLocation(), Record); for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end(); I != End; ++I) Writer.AddDeclRef(*I, Record); Code = serialization::EXPR_FUNCTION_PARM_PACK; } void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { VisitExpr(E); Writer.AddStmt(E->Temporary); Writer.AddDeclRef(E->ExtendingDecl, Record); Code = serialization::EXPR_MATERIALIZE_TEMPORARY; } void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { VisitExpr(E); Writer.AddStmt(E->getSourceExpr()); Writer.AddSourceLocation(E->getLocation(), Record); Code = serialization::EXPR_OPAQUE_VALUE; } //===----------------------------------------------------------------------===// // CUDA Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { VisitCallExpr(E); Writer.AddStmt(E->getConfig()); Code = serialization::EXPR_CUDA_KERNEL_CALL; } //===----------------------------------------------------------------------===// // OpenCL Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Writer.AddStmt(E->getSrcExpr()); Code = serialization::EXPR_ASTYPE; } //===----------------------------------------------------------------------===// // Microsoft Expressions and Statements. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { VisitExpr(E); Record.push_back(E->isArrow()); Writer.AddStmt(E->getBaseExpr()); Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); Writer.AddSourceLocation(E->getMemberLoc(), Record); Writer.AddDeclRef(E->getPropertyDecl(), Record); Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR; } void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) { VisitExpr(E); Writer.AddSourceRange(E->getSourceRange(), Record); if (E->isTypeOperand()) { Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record); Code = serialization::EXPR_CXX_UUIDOF_TYPE; } else { Writer.AddStmt(E->getExprOperand()); Code = serialization::EXPR_CXX_UUIDOF_EXPR; } } void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getExceptLoc(), Record); Writer.AddStmt(S->getFilterExpr()); Writer.AddStmt(S->getBlock()); Code = serialization::STMT_SEH_EXCEPT; } void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getFinallyLoc(), Record); Writer.AddStmt(S->getBlock()); Code = serialization::STMT_SEH_FINALLY; } void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) { VisitStmt(S); Record.push_back(S->getIsCXXTry()); Writer.AddSourceLocation(S->getTryLoc(), Record); Writer.AddStmt(S->getTryBlock()); Writer.AddStmt(S->getHandler()); Code = serialization::STMT_SEH_TRY; } //===----------------------------------------------------------------------===// // OpenMP Clauses. //===----------------------------------------------------------------------===// namespace clang { class OMPClauseWriter : public OMPClauseVisitor { ASTStmtWriter *Writer; ASTWriter::RecordData &Record; public: OMPClauseWriter(ASTStmtWriter *W, ASTWriter::RecordData &Record) : Writer(W), Record(Record) { } #define OPENMP_CLAUSE(Name, Class) \ void Visit##Class(Class *S); #include "clang/Basic/OpenMPKinds.def" void writeClause(OMPClause *C); }; } void OMPClauseWriter::writeClause(OMPClause *C) { Record.push_back(C->getClauseKind()); Visit(C); Writer->Writer.AddSourceLocation(C->getLocStart(), Record); Writer->Writer.AddSourceLocation(C->getLocEnd(), Record); } void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) { Writer->Writer.AddStmt(C->getCondition()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); } void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) { Record.push_back(C->getDefaultKind()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); Writer->Writer.AddSourceLocation(C->getDefaultKindKwLoc(), Record); } void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (OMPPrivateClause::varlist_iterator I = C->varlist_begin(), E = C->varlist_end(); I != E; ++I) Writer->Writer.AddStmt(*I); } void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (OMPFirstprivateClause::varlist_iterator I = C->varlist_begin(), E = C->varlist_end(); I != E; ++I) Writer->Writer.AddStmt(*I); } void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) { Record.push_back(C->varlist_size()); Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); for (OMPSharedClause::varlist_iterator I = C->varlist_begin(), E = C->varlist_end(); I != E; ++I) Writer->Writer.AddStmt(*I); } //===----------------------------------------------------------------------===// // OpenMP Directives. //===----------------------------------------------------------------------===// void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) { Writer.AddSourceLocation(E->getLocStart(), Record); Writer.AddSourceLocation(E->getLocEnd(), Record); OMPClauseWriter ClauseWriter(this, Record); for (unsigned i = 0; i < E->getNumClauses(); ++i) { ClauseWriter.writeClause(E->getClause(i)); } Writer.AddStmt(E->getAssociatedStmt()); } void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE; } void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); Record.push_back(D->getCollapsedNumber()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_SIMD_DIRECTIVE; } //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) { assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() && "SwitchCase recorded twice"); unsigned NextID = SwitchCaseIDs.size(); SwitchCaseIDs[S] = NextID; return NextID; } unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) { assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() && "SwitchCase hasn't been seen yet"); return SwitchCaseIDs[S]; } void ASTWriter::ClearSwitchCaseIDs() { SwitchCaseIDs.clear(); } /// \brief Write the given substatement or subexpression to the /// bitstream. void ASTWriter::WriteSubStmt(Stmt *S, llvm::DenseMap &SubStmtEntries, llvm::DenseSet &ParentStmts) { RecordData Record; ASTStmtWriter Writer(*this, Record); ++NumStatements; if (!S) { Stream.EmitRecord(serialization::STMT_NULL_PTR, Record); return; } llvm::DenseMap::iterator I = SubStmtEntries.find(S); if (I != SubStmtEntries.end()) { Record.push_back(I->second); Stream.EmitRecord(serialization::STMT_REF_PTR, Record); return; } #ifndef NDEBUG assert(!ParentStmts.count(S) && "There is a Stmt cycle!"); struct ParentStmtInserterRAII { Stmt *S; llvm::DenseSet &ParentStmts; ParentStmtInserterRAII(Stmt *S, llvm::DenseSet &ParentStmts) : S(S), ParentStmts(ParentStmts) { ParentStmts.insert(S); } ~ParentStmtInserterRAII() { ParentStmts.erase(S); } }; ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts); #endif // Redirect ASTWriter::AddStmt to collect sub-stmts. SmallVector SubStmts; CollectedStmts = &SubStmts; Writer.Code = serialization::STMT_NULL_PTR; Writer.AbbrevToUse = 0; Writer.Visit(S); #ifndef NDEBUG if (Writer.Code == serialization::STMT_NULL_PTR) { SourceManager &SrcMgr = DeclIDs.begin()->first->getASTContext().getSourceManager(); S->dump(SrcMgr); llvm_unreachable("Unhandled sub-statement writing AST file"); } #endif // Revert ASTWriter::AddStmt. CollectedStmts = &StmtsToEmit; // Write the sub-stmts in reverse order, last to first. When reading them back // we will read them in correct order by "pop"ing them from the Stmts stack. // This simplifies reading and allows to store a variable number of sub-stmts // without knowing it in advance. while (!SubStmts.empty()) WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts); Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse); SubStmtEntries[S] = Stream.GetCurrentBitNo(); } /// \brief Flush all of the statements that have been added to the /// queue via AddStmt(). void ASTWriter::FlushStmts() { RecordData Record; // We expect to be the only consumer of the two temporary statement maps, // assert that they are empty. assert(SubStmtEntries.empty() && "unexpected entries in sub-stmt map"); assert(ParentStmts.empty() && "unexpected entries in parent stmt map"); for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts); assert(N == StmtsToEmit.size() && "Substatement written via AddStmt rather than WriteSubStmt!"); // Note that we are at the end of a full expression. Any // expression records that follow this one are part of a different // expression. Stream.EmitRecord(serialization::STMT_STOP, Record); SubStmtEntries.clear(); ParentStmts.clear(); } StmtsToEmit.clear(); } @