contrib/llvm/tools/clang/lib/Serialization/ASTWriterStmt.cpp

   1 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// \brief Implements serialization for Statements and Expressions.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Serialization/ASTWriter.h"
  16 #include "clang/AST/ASTContext.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/DeclObjC.h"
  19 #include "clang/AST/DeclTemplate.h"
  20 #include "clang/AST/StmtVisitor.h"
  21 #include "clang/Lex/Token.h"
  22 #include "llvm/Bitcode/BitstreamWriter.h"
  23 using namespace clang;
  24
  25 //===----------------------------------------------------------------------===//
  26 // Statement/expression serialization
  27 //===----------------------------------------------------------------------===//
  28
  29 namespace clang {
  30
  31   class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
  32     ASTWriter &Writer;
  33     ASTRecordWriter Record;
  34
  35     serialization::StmtCode Code;
  36     unsigned AbbrevToUse;
  37
  38   public:
  39     ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
  40         : Writer(Writer), Record(Writer, Record),
  41           Code(serialization::STMT_NULL_PTR), AbbrevToUse(0) {}
  42
  43     ASTStmtWriter(const ASTStmtWriter&) = delete;
  44
  45     uint64_t Emit() {
  46       assert(Code != serialization::STMT_NULL_PTR &&
  47              "unhandled sub-statement writing AST file");
  48       return Record.EmitStmt(Code, AbbrevToUse);
  49     }
  50
  51     void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo,
  52                                   const TemplateArgumentLoc *Args);
  53
  54     void VisitStmt(Stmt *S);
  55 #define STMT(Type, Base) \
  56     void Visit##Type(Type *);
  57 #include "clang/AST/StmtNodes.inc"
  58   };
  59 }
  60
  61 void ASTStmtWriter::AddTemplateKWAndArgsInfo(
  62     const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) {
  63   Record.AddSourceLocation(ArgInfo.TemplateKWLoc);
  64   Record.AddSourceLocation(ArgInfo.LAngleLoc);
  65   Record.AddSourceLocation(ArgInfo.RAngleLoc);
  66   for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i)
  67     Record.AddTemplateArgumentLoc(Args[i]);
  68 }
  69
  70 void ASTStmtWriter::VisitStmt(Stmt *S) {
  71 }
  72
  73 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
  74   VisitStmt(S);
  75   Record.AddSourceLocation(S->getSemiLoc());
  76   Record.push_back(S->HasLeadingEmptyMacro);
  77   Code = serialization::STMT_NULL;
  78 }
  79
  80 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
  81   VisitStmt(S);
  82   Record.push_back(S->size());
  83   for (auto *CS : S->body())
  84     Record.AddStmt(CS);
  85   Record.AddSourceLocation(S->getLBracLoc());
  86   Record.AddSourceLocation(S->getRBracLoc());
  87   Code = serialization::STMT_COMPOUND;
  88 }
  89
  90 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
  91   VisitStmt(S);
  92   Record.push_back(Writer.getSwitchCaseID(S));
  93   Record.AddSourceLocation(S->getKeywordLoc());
  94   Record.AddSourceLocation(S->getColonLoc());
  95 }
  96
  97 void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
  98   VisitSwitchCase(S);
  99   Record.AddStmt(S->getLHS());
 100   Record.AddStmt(S->getRHS());
 101   Record.AddStmt(S->getSubStmt());
 102   Record.AddSourceLocation(S->getEllipsisLoc());
 103   Code = serialization::STMT_CASE;
 104 }
 105
 106 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
 107   VisitSwitchCase(S);
 108   Record.AddStmt(S->getSubStmt());
 109   Code = serialization::STMT_DEFAULT;
 110 }
 111
 112 void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
 113   VisitStmt(S);
 114   Record.AddDeclRef(S->getDecl());
 115   Record.AddStmt(S->getSubStmt());
 116   Record.AddSourceLocation(S->getIdentLoc());
 117   Code = serialization::STMT_LABEL;
 118 }
 119
 120 void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {
 121   VisitStmt(S);
 122   Record.push_back(S->getAttrs().size());
 123   Record.AddAttributes(S->getAttrs());
 124   Record.AddStmt(S->getSubStmt());
 125   Record.AddSourceLocation(S->getAttrLoc());
 126   Code = serialization::STMT_ATTRIBUTED;
 127 }
 128
 129 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
 130   VisitStmt(S);
 131   Record.push_back(S->isConstexpr());
 132   Record.AddStmt(S->getInit());
 133   Record.AddDeclRef(S->getConditionVariable());
 134   Record.AddStmt(S->getCond());
 135   Record.AddStmt(S->getThen());
 136   Record.AddStmt(S->getElse());
 137   Record.AddSourceLocation(S->getIfLoc());
 138   Record.AddSourceLocation(S->getElseLoc());
 139   Code = serialization::STMT_IF;
 140 }
 141
 142 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
 143   VisitStmt(S);
 144   Record.AddStmt(S->getInit());
 145   Record.AddDeclRef(S->getConditionVariable());
 146   Record.AddStmt(S->getCond());
 147   Record.AddStmt(S->getBody());
 148   Record.AddSourceLocation(S->getSwitchLoc());
 149   Record.push_back(S->isAllEnumCasesCovered());
 150   for (SwitchCase *SC = S->getSwitchCaseList(); SC;
 151        SC = SC->getNextSwitchCase())
 152     Record.push_back(Writer.RecordSwitchCaseID(SC));
 153   Code = serialization::STMT_SWITCH;
 154 }
 155
 156 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
 157   VisitStmt(S);
 158   Record.AddDeclRef(S->getConditionVariable());
 159   Record.AddStmt(S->getCond());
 160   Record.AddStmt(S->getBody());
 161   Record.AddSourceLocation(S->getWhileLoc());
 162   Code = serialization::STMT_WHILE;
 163 }
 164
 165 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
 166   VisitStmt(S);
 167   Record.AddStmt(S->getCond());
 168   Record.AddStmt(S->getBody());
 169   Record.AddSourceLocation(S->getDoLoc());
 170   Record.AddSourceLocation(S->getWhileLoc());
 171   Record.AddSourceLocation(S->getRParenLoc());
 172   Code = serialization::STMT_DO;
 173 }
 174
 175 void ASTStmtWriter::VisitForStmt(ForStmt *S) {
 176   VisitStmt(S);
 177   Record.AddStmt(S->getInit());
 178   Record.AddStmt(S->getCond());
 179   Record.AddDeclRef(S->getConditionVariable());
 180   Record.AddStmt(S->getInc());
 181   Record.AddStmt(S->getBody());
 182   Record.AddSourceLocation(S->getForLoc());
 183   Record.AddSourceLocation(S->getLParenLoc());
 184   Record.AddSourceLocation(S->getRParenLoc());
 185   Code = serialization::STMT_FOR;
 186 }
 187
 188 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
 189   VisitStmt(S);
 190   Record.AddDeclRef(S->getLabel());
 191   Record.AddSourceLocation(S->getGotoLoc());
 192   Record.AddSourceLocation(S->getLabelLoc());
 193   Code = serialization::STMT_GOTO;
 194 }
 195
 196 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
 197   VisitStmt(S);
 198   Record.AddSourceLocation(S->getGotoLoc());
 199   Record.AddSourceLocation(S->getStarLoc());
 200   Record.AddStmt(S->getTarget());
 201   Code = serialization::STMT_INDIRECT_GOTO;
 202 }
 203
 204 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
 205   VisitStmt(S);
 206   Record.AddSourceLocation(S->getContinueLoc());
 207   Code = serialization::STMT_CONTINUE;
 208 }
 209
 210 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
 211   VisitStmt(S);
 212   Record.AddSourceLocation(S->getBreakLoc());
 213   Code = serialization::STMT_BREAK;
 214 }
 215
 216 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
 217   VisitStmt(S);
 218   Record.AddStmt(S->getRetValue());
 219   Record.AddSourceLocation(S->getReturnLoc());
 220   Record.AddDeclRef(S->getNRVOCandidate());
 221   Code = serialization::STMT_RETURN;
 222 }
 223
 224 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
 225   VisitStmt(S);
 226   Record.AddSourceLocation(S->getStartLoc());
 227   Record.AddSourceLocation(S->getEndLoc());
 228   DeclGroupRef DG = S->getDeclGroup();
 229   for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
 230     Record.AddDeclRef(*D);
 231   Code = serialization::STMT_DECL;
 232 }
 233
 234 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
 235   VisitStmt(S);
 236   Record.push_back(S->getNumOutputs());
 237   Record.push_back(S->getNumInputs());
 238   Record.push_back(S->getNumClobbers());
 239   Record.AddSourceLocation(S->getAsmLoc());
 240   Record.push_back(S->isVolatile());
 241   Record.push_back(S->isSimple());
 242 }
 243
 244 void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) {
 245   VisitAsmStmt(S);
 246   Record.AddSourceLocation(S->getRParenLoc());
 247   Record.AddStmt(S->getAsmString());
 248
 249   // Outputs
 250   for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
 251     Record.AddIdentifierRef(S->getOutputIdentifier(I));
 252     Record.AddStmt(S->getOutputConstraintLiteral(I));
 253     Record.AddStmt(S->getOutputExpr(I));
 254   }
 255
 256   // Inputs
 257   for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
 258     Record.AddIdentifierRef(S->getInputIdentifier(I));
 259     Record.AddStmt(S->getInputConstraintLiteral(I));
 260     Record.AddStmt(S->getInputExpr(I));
 261   }
 262
 263   // Clobbers
 264   for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
 265     Record.AddStmt(S->getClobberStringLiteral(I));
 266
 267   Code = serialization::STMT_GCCASM;
 268 }
 269
 270 void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {
 271   VisitAsmStmt(S);
 272   Record.AddSourceLocation(S->getLBraceLoc());
 273   Record.AddSourceLocation(S->getEndLoc());
 274   Record.push_back(S->getNumAsmToks());
 275   Record.AddString(S->getAsmString());
 276
 277   // Tokens
 278   for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) {
 279     // FIXME: Move this to ASTRecordWriter?
 280     Writer.AddToken(S->getAsmToks()[I], Record.getRecordData());
 281   }
 282
 283   // Clobbers
 284   for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) {
 285     Record.AddString(S->getClobber(I));
 286   }
 287
 288   // Outputs
 289   for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
 290     Record.AddStmt(S->getOutputExpr(I));
 291     Record.AddString(S->getOutputConstraint(I));
 292   }
 293
 294   // Inputs
 295   for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
 296     Record.AddStmt(S->getInputExpr(I));
 297     Record.AddString(S->getInputConstraint(I));
 298   }
 299
 300   Code = serialization::STMT_MSASM;
 301 }
 302
 303 void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
 304   // FIXME: Implement coroutine serialization.
 305   llvm_unreachable("unimplemented");
 306 }
 307
 308 void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) {
 309   // FIXME: Implement coroutine serialization.
 310   llvm_unreachable("unimplemented");
 311 }
 312
 313 void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *S) {
 314   // FIXME: Implement coroutine serialization.
 315   llvm_unreachable("unimplemented");
 316 }
 317
 318 void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *S) {
 319   // FIXME: Implement coroutine serialization.
 320   llvm_unreachable("unimplemented");
 321 }
 322
 323 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
 324   VisitStmt(S);
 325   // NumCaptures
 326   Record.push_back(std::distance(S->capture_begin(), S->capture_end()));
 327
 328   // CapturedDecl and captured region kind
 329   Record.AddDeclRef(S->getCapturedDecl());
 330   Record.push_back(S->getCapturedRegionKind());
 331
 332   Record.AddDeclRef(S->getCapturedRecordDecl());
 333
 334   // Capture inits
 335   for (auto *I : S->capture_inits())
 336     Record.AddStmt(I);
 337
 338   // Body
 339   Record.AddStmt(S->getCapturedStmt());
 340
 341   // Captures
 342   for (const auto &I : S->captures()) {
 343     if (I.capturesThis() || I.capturesVariableArrayType())
 344       Record.AddDeclRef(nullptr);
 345     else
 346       Record.AddDeclRef(I.getCapturedVar());
 347     Record.push_back(I.getCaptureKind());
 348     Record.AddSourceLocation(I.getLocation());
 349   }
 350
 351   Code = serialization::STMT_CAPTURED;
 352 }
 353
 354 void ASTStmtWriter::VisitExpr(Expr *E) {
 355   VisitStmt(E);
 356   Record.AddTypeRef(E->getType());
 357   Record.push_back(E->isTypeDependent());
 358   Record.push_back(E->isValueDependent());
 359   Record.push_back(E->isInstantiationDependent());
 360   Record.push_back(E->containsUnexpandedParameterPack());
 361   Record.push_back(E->getValueKind());
 362   Record.push_back(E->getObjectKind());
 363 }
 364
 365 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
 366   VisitExpr(E);
 367   Record.AddSourceLocation(E->getLocation());
 368   Record.push_back(E->getIdentType()); // FIXME: stable encoding
 369   Record.AddStmt(E->getFunctionName());
 370   Code = serialization::EXPR_PREDEFINED;
 371 }
 372
 373 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
 374   VisitExpr(E);
 375
 376   Record.push_back(E->hasQualifier());
 377   Record.push_back(E->getDecl() != E->getFoundDecl());
 378   Record.push_back(E->hasTemplateKWAndArgsInfo());
 379   Record.push_back(E->hadMultipleCandidates());
 380   Record.push_back(E->refersToEnclosingVariableOrCapture());
 381
 382   if (E->hasTemplateKWAndArgsInfo()) {
 383     unsigned NumTemplateArgs = E->getNumTemplateArgs();
 384     Record.push_back(NumTemplateArgs);
 385   }
 386
 387   DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
 388
 389   if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
 390       (E->getDecl() == E->getFoundDecl()) &&
 391       nk == DeclarationName::Identifier) {
 392     AbbrevToUse = Writer.getDeclRefExprAbbrev();
 393   }
 394
 395   if (E->hasQualifier())
 396     Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
 397
 398   if (E->getDecl() != E->getFoundDecl())
 399     Record.AddDeclRef(E->getFoundDecl());
 400
 401   if (E->hasTemplateKWAndArgsInfo())
 402     AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
 403                              E->getTrailingObjects<TemplateArgumentLoc>());
 404
 405   Record.AddDeclRef(E->getDecl());
 406   Record.AddSourceLocation(E->getLocation());
 407   Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
 408   Code = serialization::EXPR_DECL_REF;
 409 }
 410
 411 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
 412   VisitExpr(E);
 413   Record.AddSourceLocation(E->getLocation());
 414   Record.AddAPInt(E->getValue());
 415
 416   if (E->getValue().getBitWidth() == 32) {
 417     AbbrevToUse = Writer.getIntegerLiteralAbbrev();
 418   }
 419
 420   Code = serialization::EXPR_INTEGER_LITERAL;
 421 }
 422
 423 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
 424   VisitExpr(E);
 425   Record.push_back(E->getRawSemantics());
 426   Record.push_back(E->isExact());
 427   Record.AddAPFloat(E->getValue());
 428   Record.AddSourceLocation(E->getLocation());
 429   Code = serialization::EXPR_FLOATING_LITERAL;
 430 }
 431
 432 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
 433   VisitExpr(E);
 434   Record.AddStmt(E->getSubExpr());
 435   Code = serialization::EXPR_IMAGINARY_LITERAL;
 436 }
 437
 438 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
 439   VisitExpr(E);
 440   Record.push_back(E->getByteLength());
 441   Record.push_back(E->getNumConcatenated());
 442   Record.push_back(E->getKind());
 443   Record.push_back(E->isPascal());
 444   // FIXME: String data should be stored as a blob at the end of the
 445   // StringLiteral. However, we can't do so now because we have no
 446   // provision for coping with abbreviations when we're jumping around
 447   // the AST file during deserialization.
 448   Record.append(E->getBytes().begin(), E->getBytes().end());
 449   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
 450     Record.AddSourceLocation(E->getStrTokenLoc(I));
 451   Code = serialization::EXPR_STRING_LITERAL;
 452 }
 453
 454 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
 455   VisitExpr(E);
 456   Record.push_back(E->getValue());
 457   Record.AddSourceLocation(E->getLocation());
 458   Record.push_back(E->getKind());
 459
 460   AbbrevToUse = Writer.getCharacterLiteralAbbrev();
 461
 462   Code = serialization::EXPR_CHARACTER_LITERAL;
 463 }
 464
 465 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
 466   VisitExpr(E);
 467   Record.AddSourceLocation(E->getLParen());
 468   Record.AddSourceLocation(E->getRParen());
 469   Record.AddStmt(E->getSubExpr());
 470   Code = serialization::EXPR_PAREN;
 471 }
 472
 473 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
 474   VisitExpr(E);
 475   Record.push_back(E->NumExprs);
 476   for (unsigned i=0; i != E->NumExprs; ++i)
 477     Record.AddStmt(E->Exprs[i]);
 478   Record.AddSourceLocation(E->LParenLoc);
 479   Record.AddSourceLocation(E->RParenLoc);
 480   Code = serialization::EXPR_PAREN_LIST;
 481 }
 482
 483 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
 484   VisitExpr(E);
 485   Record.AddStmt(E->getSubExpr());
 486   Record.push_back(E->getOpcode()); // FIXME: stable encoding
 487   Record.AddSourceLocation(E->getOperatorLoc());
 488   Code = serialization::EXPR_UNARY_OPERATOR;
 489 }
 490
 491 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
 492   VisitExpr(E);
 493   Record.push_back(E->getNumComponents());
 494   Record.push_back(E->getNumExpressions());
 495   Record.AddSourceLocation(E->getOperatorLoc());
 496   Record.AddSourceLocation(E->getRParenLoc());
 497   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
 498   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
 499     const OffsetOfNode &ON = E->getComponent(I);
 500     Record.push_back(ON.getKind()); // FIXME: Stable encoding
 501     Record.AddSourceLocation(ON.getSourceRange().getBegin());
 502     Record.AddSourceLocation(ON.getSourceRange().getEnd());
 503     switch (ON.getKind()) {
 504     case OffsetOfNode::Array:
 505       Record.push_back(ON.getArrayExprIndex());
 506       break;
 507
 508     case OffsetOfNode::Field:
 509       Record.AddDeclRef(ON.getField());
 510       break;
 511
 512     case OffsetOfNode::Identifier:
 513       Record.AddIdentifierRef(ON.getFieldName());
 514       break;
 515
 516     case OffsetOfNode::Base:
 517       Record.AddCXXBaseSpecifier(*ON.getBase());
 518       break;
 519     }
 520   }
 521   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
 522     Record.AddStmt(E->getIndexExpr(I));
 523   Code = serialization::EXPR_OFFSETOF;
 524 }
 525
 526 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
 527   VisitExpr(E);
 528   Record.push_back(E->getKind());
 529   if (E->isArgumentType())
 530     Record.AddTypeSourceInfo(E->getArgumentTypeInfo());
 531   else {
 532     Record.push_back(0);
 533     Record.AddStmt(E->getArgumentExpr());
 534   }
 535   Record.AddSourceLocation(E->getOperatorLoc());
 536   Record.AddSourceLocation(E->getRParenLoc());
 537   Code = serialization::EXPR_SIZEOF_ALIGN_OF;
 538 }
 539
 540 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 541   VisitExpr(E);
 542   Record.AddStmt(E->getLHS());
 543   Record.AddStmt(E->getRHS());
 544   Record.AddSourceLocation(E->getRBracketLoc());
 545   Code = serialization::EXPR_ARRAY_SUBSCRIPT;
 546 }
 547
 548 void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
 549   VisitExpr(E);
 550   Record.AddStmt(E->getBase());
 551   Record.AddStmt(E->getLowerBound());
 552   Record.AddStmt(E->getLength());
 553   Record.AddSourceLocation(E->getColonLoc());
 554   Record.AddSourceLocation(E->getRBracketLoc());
 555   Code = serialization::EXPR_OMP_ARRAY_SECTION;
 556 }
 557
 558 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
 559   VisitExpr(E);
 560   Record.push_back(E->getNumArgs());
 561   Record.AddSourceLocation(E->getRParenLoc());
 562   Record.AddStmt(E->getCallee());
 563   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
 564        Arg != ArgEnd; ++Arg)
 565     Record.AddStmt(*Arg);
 566   Code = serialization::EXPR_CALL;
 567 }
 568
 569 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
 570   // Don't call VisitExpr, we'll write everything here.
 571
 572   Record.push_back(E->hasQualifier());
 573   if (E->hasQualifier())
 574     Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
 575
 576   Record.push_back(E->HasTemplateKWAndArgsInfo);
 577   if (E->HasTemplateKWAndArgsInfo) {
 578     Record.AddSourceLocation(E->getTemplateKeywordLoc());
 579     unsigned NumTemplateArgs = E->getNumTemplateArgs();
 580     Record.push_back(NumTemplateArgs);
 581     Record.AddSourceLocation(E->getLAngleLoc());
 582     Record.AddSourceLocation(E->getRAngleLoc());
 583     for (unsigned i=0; i != NumTemplateArgs; ++i)
 584       Record.AddTemplateArgumentLoc(E->getTemplateArgs()[i]);
 585   }
 586
 587   Record.push_back(E->hadMultipleCandidates());
 588
 589   DeclAccessPair FoundDecl = E->getFoundDecl();
 590   Record.AddDeclRef(FoundDecl.getDecl());
 591   Record.push_back(FoundDecl.getAccess());
 592
 593   Record.AddTypeRef(E->getType());
 594   Record.push_back(E->getValueKind());
 595   Record.push_back(E->getObjectKind());
 596   Record.AddStmt(E->getBase());
 597   Record.AddDeclRef(E->getMemberDecl());
 598   Record.AddSourceLocation(E->getMemberLoc());
 599   Record.push_back(E->isArrow());
 600   Record.AddSourceLocation(E->getOperatorLoc());
 601   Record.AddDeclarationNameLoc(E->MemberDNLoc,
 602                                E->getMemberDecl()->getDeclName());
 603   Code = serialization::EXPR_MEMBER;
 604 }
 605
 606 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
 607   VisitExpr(E);
 608   Record.AddStmt(E->getBase());
 609   Record.AddSourceLocation(E->getIsaMemberLoc());
 610   Record.AddSourceLocation(E->getOpLoc());
 611   Record.push_back(E->isArrow());
 612   Code = serialization::EXPR_OBJC_ISA;
 613 }
 614
 615 void ASTStmtWriter::
 616 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
 617   VisitExpr(E);
 618   Record.AddStmt(E->getSubExpr());
 619   Record.push_back(E->shouldCopy());
 620   Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE;
 621 }
 622
 623 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
 624   VisitExplicitCastExpr(E);
 625   Record.AddSourceLocation(E->getLParenLoc());
 626   Record.AddSourceLocation(E->getBridgeKeywordLoc());
 627   Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
 628   Code = serialization::EXPR_OBJC_BRIDGED_CAST;
 629 }
 630
 631 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
 632   VisitExpr(E);
 633   Record.push_back(E->path_size());
 634   Record.AddStmt(E->getSubExpr());
 635   Record.push_back(E->getCastKind()); // FIXME: stable encoding
 636
 637   for (CastExpr::path_iterator
 638          PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
 639     Record.AddCXXBaseSpecifier(**PI);
 640 }
 641
 642 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
 643   VisitExpr(E);
 644   Record.AddStmt(E->getLHS());
 645   Record.AddStmt(E->getRHS());
 646   Record.push_back(E->getOpcode()); // FIXME: stable encoding
 647   Record.AddSourceLocation(E->getOperatorLoc());
 648   Record.push_back(E->isFPContractable());
 649   Code = serialization::EXPR_BINARY_OPERATOR;
 650 }
 651
 652 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 653   VisitBinaryOperator(E);
 654   Record.AddTypeRef(E->getComputationLHSType());
 655   Record.AddTypeRef(E->getComputationResultType());
 656   Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
 657 }
 658
 659 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
 660   VisitExpr(E);
 661   Record.AddStmt(E->getCond());
 662   Record.AddStmt(E->getLHS());
 663   Record.AddStmt(E->getRHS());
 664   Record.AddSourceLocation(E->getQuestionLoc());
 665   Record.AddSourceLocation(E->getColonLoc());
 666   Code = serialization::EXPR_CONDITIONAL_OPERATOR;
 667 }
 668
 669 void
 670 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
 671   VisitExpr(E);
 672   Record.AddStmt(E->getOpaqueValue());
 673   Record.AddStmt(E->getCommon());
 674   Record.AddStmt(E->getCond());
 675   Record.AddStmt(E->getTrueExpr());
 676   Record.AddStmt(E->getFalseExpr());
 677   Record.AddSourceLocation(E->getQuestionLoc());
 678   Record.AddSourceLocation(E->getColonLoc());
 679   Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
 680 }
 681
 682 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
 683   VisitCastExpr(E);
 684
 685   if (E->path_size() == 0)
 686     AbbrevToUse = Writer.getExprImplicitCastAbbrev();
 687
 688   Code = serialization::EXPR_IMPLICIT_CAST;
 689 }
 690
 691 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
 692   VisitCastExpr(E);
 693   Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());
 694 }
 695
 696 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
 697   VisitExplicitCastExpr(E);
 698   Record.AddSourceLocation(E->getLParenLoc());
 699   Record.AddSourceLocation(E->getRParenLoc());
 700   Code = serialization::EXPR_CSTYLE_CAST;
 701 }
 702
 703 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 704   VisitExpr(E);
 705   Record.AddSourceLocation(E->getLParenLoc());
 706   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
 707   Record.AddStmt(E->getInitializer());
 708   Record.push_back(E->isFileScope());
 709   Code = serialization::EXPR_COMPOUND_LITERAL;
 710 }
 711
 712 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
 713   VisitExpr(E);
 714   Record.AddStmt(E->getBase());
 715   Record.AddIdentifierRef(&E->getAccessor());
 716   Record.AddSourceLocation(E->getAccessorLoc());
 717   Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
 718 }
 719
 720 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
 721   VisitExpr(E);
 722   // NOTE: only add the (possibly null) syntactic form.
 723   // No need to serialize the isSemanticForm flag and the semantic form.
 724   Record.AddStmt(E->getSyntacticForm());
 725   Record.AddSourceLocation(E->getLBraceLoc());
 726   Record.AddSourceLocation(E->getRBraceLoc());
 727   bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
 728   Record.push_back(isArrayFiller);
 729   if (isArrayFiller)
 730     Record.AddStmt(E->getArrayFiller());
 731   else
 732     Record.AddDeclRef(E->getInitializedFieldInUnion());
 733   Record.push_back(E->hadArrayRangeDesignator());
 734   Record.push_back(E->getNumInits());
 735   if (isArrayFiller) {
 736     // ArrayFiller may have filled "holes" due to designated initializer.
 737     // Replace them by 0 to indicate that the filler goes in that place.
 738     Expr *filler = E->getArrayFiller();
 739     for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
 740       Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);
 741   } else {
 742     for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
 743       Record.AddStmt(E->getInit(I));
 744   }
 745   Code = serialization::EXPR_INIT_LIST;
 746 }
 747
 748 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
 749   VisitExpr(E);
 750   Record.push_back(E->getNumSubExprs());
 751   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
 752     Record.AddStmt(E->getSubExpr(I));
 753   Record.AddSourceLocation(E->getEqualOrColonLoc());
 754   Record.push_back(E->usesGNUSyntax());
 755   for (const DesignatedInitExpr::Designator &D : E->designators()) {
 756     if (D.isFieldDesignator()) {
 757       if (FieldDecl *Field = D.getField()) {
 758         Record.push_back(serialization::DESIG_FIELD_DECL);
 759         Record.AddDeclRef(Field);
 760       } else {
 761         Record.push_back(serialization::DESIG_FIELD_NAME);
 762         Record.AddIdentifierRef(D.getFieldName());
 763       }
 764       Record.AddSourceLocation(D.getDotLoc());
 765       Record.AddSourceLocation(D.getFieldLoc());
 766     } else if (D.isArrayDesignator()) {
 767       Record.push_back(serialization::DESIG_ARRAY);
 768       Record.push_back(D.getFirstExprIndex());
 769       Record.AddSourceLocation(D.getLBracketLoc());
 770       Record.AddSourceLocation(D.getRBracketLoc());
 771     } else {
 772       assert(D.isArrayRangeDesignator() && "Unknown designator");
 773       Record.push_back(serialization::DESIG_ARRAY_RANGE);
 774       Record.push_back(D.getFirstExprIndex());
 775       Record.AddSourceLocation(D.getLBracketLoc());
 776       Record.AddSourceLocation(D.getEllipsisLoc());
 777       Record.AddSourceLocation(D.getRBracketLoc());
 778     }
 779   }
 780   Code = serialization::EXPR_DESIGNATED_INIT;
 781 }
 782
 783 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
 784   VisitExpr(E);
 785   Record.AddStmt(E->getBase());
 786   Record.AddStmt(E->getUpdater());
 787   Code = serialization::EXPR_DESIGNATED_INIT_UPDATE;
 788 }
 789
 790 void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
 791   VisitExpr(E);
 792   Code = serialization::EXPR_NO_INIT;
 793 }
 794
 795 void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
 796   VisitExpr(E);
 797   Record.AddStmt(E->SubExprs[0]);
 798   Record.AddStmt(E->SubExprs[1]);
 799   Code = serialization::EXPR_ARRAY_INIT_LOOP;
 800 }
 801
 802 void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
 803   VisitExpr(E);
 804   Code = serialization::EXPR_ARRAY_INIT_INDEX;
 805 }
 806
 807 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 808   VisitExpr(E);
 809   Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
 810 }
 811
 812 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
 813   VisitExpr(E);
 814   Record.AddStmt(E->getSubExpr());
 815   Record.AddTypeSourceInfo(E->getWrittenTypeInfo());
 816   Record.AddSourceLocation(E->getBuiltinLoc());
 817   Record.AddSourceLocation(E->getRParenLoc());
 818   Record.push_back(E->isMicrosoftABI());
 819   Code = serialization::EXPR_VA_ARG;
 820 }
 821
 822 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
 823   VisitExpr(E);
 824   Record.AddSourceLocation(E->getAmpAmpLoc());
 825   Record.AddSourceLocation(E->getLabelLoc());
 826   Record.AddDeclRef(E->getLabel());
 827   Code = serialization::EXPR_ADDR_LABEL;
 828 }
 829
 830 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
 831   VisitExpr(E);
 832   Record.AddStmt(E->getSubStmt());
 833   Record.AddSourceLocation(E->getLParenLoc());
 834   Record.AddSourceLocation(E->getRParenLoc());
 835   Code = serialization::EXPR_STMT;
 836 }
 837
 838 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
 839   VisitExpr(E);
 840   Record.AddStmt(E->getCond());
 841   Record.AddStmt(E->getLHS());
 842   Record.AddStmt(E->getRHS());
 843   Record.AddSourceLocation(E->getBuiltinLoc());
 844   Record.AddSourceLocation(E->getRParenLoc());
 845   Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
 846   Code = serialization::EXPR_CHOOSE;
 847 }
 848
 849 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
 850   VisitExpr(E);
 851   Record.AddSourceLocation(E->getTokenLocation());
 852   Code = serialization::EXPR_GNU_NULL;
 853 }
 854
 855 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
 856   VisitExpr(E);
 857   Record.push_back(E->getNumSubExprs());
 858   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
 859     Record.AddStmt(E->getExpr(I));
 860   Record.AddSourceLocation(E->getBuiltinLoc());
 861   Record.AddSourceLocation(E->getRParenLoc());
 862   Code = serialization::EXPR_SHUFFLE_VECTOR;
 863 }
 864
 865 void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
 866   VisitExpr(E);
 867   Record.AddSourceLocation(E->getBuiltinLoc());
 868   Record.AddSourceLocation(E->getRParenLoc());
 869   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
 870   Record.AddStmt(E->getSrcExpr());
 871   Code = serialization::EXPR_CONVERT_VECTOR;
 872 }
 873
 874 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
 875   VisitExpr(E);
 876   Record.AddDeclRef(E->getBlockDecl());
 877   Code = serialization::EXPR_BLOCK;
 878 }
 879
 880 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
 881   VisitExpr(E);
 882   Record.push_back(E->getNumAssocs());
 883
 884   Record.AddStmt(E->getControllingExpr());
 885   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
 886     Record.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I));
 887     Record.AddStmt(E->getAssocExpr(I));
 888   }
 889   Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex());
 890
 891   Record.AddSourceLocation(E->getGenericLoc());
 892   Record.AddSourceLocation(E->getDefaultLoc());
 893   Record.AddSourceLocation(E->getRParenLoc());
 894   Code = serialization::EXPR_GENERIC_SELECTION;
 895 }
 896
 897 void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
 898   VisitExpr(E);
 899   Record.push_back(E->getNumSemanticExprs());
 900
 901   // Push the result index.  Currently, this needs to exactly match
 902   // the encoding used internally for ResultIndex.
 903   unsigned result = E->getResultExprIndex();
 904   result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1);
 905   Record.push_back(result);
 906
 907   Record.AddStmt(E->getSyntacticForm());
 908   for (PseudoObjectExpr::semantics_iterator
 909          i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
 910     Record.AddStmt(*i);
 911   }
 912   Code = serialization::EXPR_PSEUDO_OBJECT;
 913 }
 914
 915 void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
 916   VisitExpr(E);
 917   Record.push_back(E->getOp());
 918   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
 919     Record.AddStmt(E->getSubExprs()[I]);
 920   Record.AddSourceLocation(E->getBuiltinLoc());
 921   Record.AddSourceLocation(E->getRParenLoc());
 922   Code = serialization::EXPR_ATOMIC;
 923 }
 924
 925 //===----------------------------------------------------------------------===//
 926 // Objective-C Expressions and Statements.
 927 //===----------------------------------------------------------------------===//
 928
 929 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
 930   VisitExpr(E);
 931   Record.AddStmt(E->getString());
 932   Record.AddSourceLocation(E->getAtLoc());
 933   Code = serialization::EXPR_OBJC_STRING_LITERAL;
 934 }
 935
 936 void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
 937   VisitExpr(E);
 938   Record.AddStmt(E->getSubExpr());
 939   Record.AddDeclRef(E->getBoxingMethod());
 940   Record.AddSourceRange(E->getSourceRange());
 941   Code = serialization::EXPR_OBJC_BOXED_EXPRESSION;
 942 }
 943
 944 void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
 945   VisitExpr(E);
 946   Record.push_back(E->getNumElements());
 947   for (unsigned i = 0; i < E->getNumElements(); i++)
 948     Record.AddStmt(E->getElement(i));
 949   Record.AddDeclRef(E->getArrayWithObjectsMethod());
 950   Record.AddSourceRange(E->getSourceRange());
 951   Code = serialization::EXPR_OBJC_ARRAY_LITERAL;
 952 }
 953
 954 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
 955   VisitExpr(E);
 956   Record.push_back(E->getNumElements());
 957   Record.push_back(E->HasPackExpansions);
 958   for (unsigned i = 0; i < E->getNumElements(); i++) {
 959     ObjCDictionaryElement Element = E->getKeyValueElement(i);
 960     Record.AddStmt(Element.Key);
 961     Record.AddStmt(Element.Value);
 962     if (E->HasPackExpansions) {
 963       Record.AddSourceLocation(Element.EllipsisLoc);
 964       unsigned NumExpansions = 0;
 965       if (Element.NumExpansions)
 966         NumExpansions = *Element.NumExpansions + 1;
 967       Record.push_back(NumExpansions);
 968     }
 969   }
 970
 971   Record.AddDeclRef(E->getDictWithObjectsMethod());
 972   Record.AddSourceRange(E->getSourceRange());
 973   Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL;
 974 }
 975
 976 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
 977   VisitExpr(E);
 978   Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo());
 979   Record.AddSourceLocation(E->getAtLoc());
 980   Record.AddSourceLocation(E->getRParenLoc());
 981   Code = serialization::EXPR_OBJC_ENCODE;
 982 }
 983
 984 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
 985   VisitExpr(E);
 986   Record.AddSelectorRef(E->getSelector());
 987   Record.AddSourceLocation(E->getAtLoc());
 988   Record.AddSourceLocation(E->getRParenLoc());
 989   Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
 990 }
 991
 992 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
 993   VisitExpr(E);
 994   Record.AddDeclRef(E->getProtocol());
 995   Record.AddSourceLocation(E->getAtLoc());
 996   Record.AddSourceLocation(E->ProtoLoc);
 997   Record.AddSourceLocation(E->getRParenLoc());
 998   Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
 999 }
1000
1001 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1002   VisitExpr(E);
1003   Record.AddDeclRef(E->getDecl());
1004   Record.AddSourceLocation(E->getLocation());
1005   Record.AddSourceLocation(E->getOpLoc());
1006   Record.AddStmt(E->getBase());
1007   Record.push_back(E->isArrow());
1008   Record.push_back(E->isFreeIvar());
1009   Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
1010 }
1011
1012 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1013   VisitExpr(E);
1014   Record.push_back(E->SetterAndMethodRefFlags.getInt());
1015   Record.push_back(E->isImplicitProperty());
1016   if (E->isImplicitProperty()) {
1017     Record.AddDeclRef(E->getImplicitPropertyGetter());
1018     Record.AddDeclRef(E->getImplicitPropertySetter());
1019   } else {
1020     Record.AddDeclRef(E->getExplicitProperty());
1021   }
1022   Record.AddSourceLocation(E->getLocation());
1023   Record.AddSourceLocation(E->getReceiverLocation());
1024   if (E->isObjectReceiver()) {
1025     Record.push_back(0);
1026     Record.AddStmt(E->getBase());
1027   } else if (E->isSuperReceiver()) {
1028     Record.push_back(1);
1029     Record.AddTypeRef(E->getSuperReceiverType());
1030   } else {
1031     Record.push_back(2);
1032     Record.AddDeclRef(E->getClassReceiver());
1033   }
1034
1035   Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
1036 }
1037
1038 void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1039   VisitExpr(E);
1040   Record.AddSourceLocation(E->getRBracket());
1041   Record.AddStmt(E->getBaseExpr());
1042   Record.AddStmt(E->getKeyExpr());
1043   Record.AddDeclRef(E->getAtIndexMethodDecl());
1044   Record.AddDeclRef(E->setAtIndexMethodDecl());
1045
1046   Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR;
1047 }
1048
1049 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1050   VisitExpr(E);
1051   Record.push_back(E->getNumArgs());
1052   Record.push_back(E->getNumStoredSelLocs());
1053   Record.push_back(E->SelLocsKind);
1054   Record.push_back(E->isDelegateInitCall());
1055   Record.push_back(E->IsImplicit);
1056   Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
1057   switch (E->getReceiverKind()) {
1058   case ObjCMessageExpr::Instance:
1059     Record.AddStmt(E->getInstanceReceiver());
1060     break;
1061
1062   case ObjCMessageExpr::Class:
1063     Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo());
1064     break;
1065
1066   case ObjCMessageExpr::SuperClass:
1067   case ObjCMessageExpr::SuperInstance:
1068     Record.AddTypeRef(E->getSuperType());
1069     Record.AddSourceLocation(E->getSuperLoc());
1070     break;
1071   }
1072
1073   if (E->getMethodDecl()) {
1074     Record.push_back(1);
1075     Record.AddDeclRef(E->getMethodDecl());
1076   } else {
1077     Record.push_back(0);
1078     Record.AddSelectorRef(E->getSelector());
1079   }
1080
1081   Record.AddSourceLocation(E->getLeftLoc());
1082   Record.AddSourceLocation(E->getRightLoc());
1083
1084   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
1085        Arg != ArgEnd; ++Arg)
1086     Record.AddStmt(*Arg);
1087
1088   SourceLocation *Locs = E->getStoredSelLocs();
1089   for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
1090     Record.AddSourceLocation(Locs[i]);
1091
1092   Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
1093 }
1094
1095 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1096   VisitStmt(S);
1097   Record.AddStmt(S->getElement());
1098   Record.AddStmt(S->getCollection());
1099   Record.AddStmt(S->getBody());
1100   Record.AddSourceLocation(S->getForLoc());
1101   Record.AddSourceLocation(S->getRParenLoc());
1102   Code = serialization::STMT_OBJC_FOR_COLLECTION;
1103 }
1104
1105 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1106   Record.AddStmt(S->getCatchBody());
1107   Record.AddDeclRef(S->getCatchParamDecl());
1108   Record.AddSourceLocation(S->getAtCatchLoc());
1109   Record.AddSourceLocation(S->getRParenLoc());
1110   Code = serialization::STMT_OBJC_CATCH;
1111 }
1112
1113 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1114   Record.AddStmt(S->getFinallyBody());
1115   Record.AddSourceLocation(S->getAtFinallyLoc());
1116   Code = serialization::STMT_OBJC_FINALLY;
1117 }
1118
1119 void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1120   Record.AddStmt(S->getSubStmt());
1121   Record.AddSourceLocation(S->getAtLoc());
1122   Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
1123 }
1124
1125 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1126   Record.push_back(S->getNumCatchStmts());
1127   Record.push_back(S->getFinallyStmt() != nullptr);
1128   Record.AddStmt(S->getTryBody());
1129   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1130     Record.AddStmt(S->getCatchStmt(I));
1131   if (S->getFinallyStmt())
1132     Record.AddStmt(S->getFinallyStmt());
1133   Record.AddSourceLocation(S->getAtTryLoc());
1134   Code = serialization::STMT_OBJC_AT_TRY;
1135 }
1136
1137 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1138   Record.AddStmt(S->getSynchExpr());
1139   Record.AddStmt(S->getSynchBody());
1140   Record.AddSourceLocation(S->getAtSynchronizedLoc());
1141   Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
1142 }
1143
1144 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1145   Record.AddStmt(S->getThrowExpr());
1146   Record.AddSourceLocation(S->getThrowLoc());
1147   Code = serialization::STMT_OBJC_AT_THROW;
1148 }
1149
1150 void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1151   VisitExpr(E);
1152   Record.push_back(E->getValue());
1153   Record.AddSourceLocation(E->getLocation());
1154   Code = serialization::EXPR_OBJC_BOOL_LITERAL;
1155 }
1156
1157 void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1158   VisitExpr(E);
1159   Record.AddSourceRange(E->getSourceRange());
1160   Record.AddVersionTuple(E->getVersion());
1161   Code = serialization::EXPR_OBJC_AVAILABILITY_CHECK;
1162 }
1163
1164 //===----------------------------------------------------------------------===//
1165 // C++ Expressions and Statements.
1166 //===----------------------------------------------------------------------===//
1167
1168 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
1169   VisitStmt(S);
1170   Record.AddSourceLocation(S->getCatchLoc());
1171   Record.AddDeclRef(S->getExceptionDecl());
1172   Record.AddStmt(S->getHandlerBlock());
1173   Code = serialization::STMT_CXX_CATCH;
1174 }
1175
1176 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
1177   VisitStmt(S);
1178   Record.push_back(S->getNumHandlers());
1179   Record.AddSourceLocation(S->getTryLoc());
1180   Record.AddStmt(S->getTryBlock());
1181   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1182     Record.AddStmt(S->getHandler(i));
1183   Code = serialization::STMT_CXX_TRY;
1184 }
1185
1186 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1187   VisitStmt(S);
1188   Record.AddSourceLocation(S->getForLoc());
1189   Record.AddSourceLocation(S->getCoawaitLoc());
1190   Record.AddSourceLocation(S->getColonLoc());
1191   Record.AddSourceLocation(S->getRParenLoc());
1192   Record.AddStmt(S->getRangeStmt());
1193   Record.AddStmt(S->getBeginStmt());
1194   Record.AddStmt(S->getEndStmt());
1195   Record.AddStmt(S->getCond());
1196   Record.AddStmt(S->getInc());
1197   Record.AddStmt(S->getLoopVarStmt());
1198   Record.AddStmt(S->getBody());
1199   Code = serialization::STMT_CXX_FOR_RANGE;
1200 }
1201
1202 void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1203   VisitStmt(S);
1204   Record.AddSourceLocation(S->getKeywordLoc());
1205   Record.push_back(S->isIfExists());
1206   Record.AddNestedNameSpecifierLoc(S->getQualifierLoc());
1207   Record.AddDeclarationNameInfo(S->getNameInfo());
1208   Record.AddStmt(S->getSubStmt());
1209   Code = serialization::STMT_MS_DEPENDENT_EXISTS;
1210 }
1211
1212 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1213   VisitCallExpr(E);
1214   Record.push_back(E->getOperator());
1215   Record.AddSourceRange(E->Range);
1216   Record.push_back(E->isFPContractable());
1217   Code = serialization::EXPR_CXX_OPERATOR_CALL;
1218 }
1219
1220 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1221   VisitCallExpr(E);
1222   Code = serialization::EXPR_CXX_MEMBER_CALL;
1223 }
1224
1225 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1226   VisitExpr(E);
1227   Record.push_back(E->getNumArgs());
1228   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1229     Record.AddStmt(E->getArg(I));
1230   Record.AddDeclRef(E->getConstructor());
1231   Record.AddSourceLocation(E->getLocation());
1232   Record.push_back(E->isElidable());
1233   Record.push_back(E->hadMultipleCandidates());
1234   Record.push_back(E->isListInitialization());
1235   Record.push_back(E->isStdInitListInitialization());
1236   Record.push_back(E->requiresZeroInitialization());
1237   Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1238   Record.AddSourceRange(E->getParenOrBraceRange());
1239   Code = serialization::EXPR_CXX_CONSTRUCT;
1240 }
1241
1242 void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1243   VisitExpr(E);
1244   Record.AddDeclRef(E->getConstructor());
1245   Record.AddSourceLocation(E->getLocation());
1246   Record.push_back(E->constructsVBase());
1247   Record.push_back(E->inheritedFromVBase());
1248   Code = serialization::EXPR_CXX_INHERITED_CTOR_INIT;
1249 }
1250
1251 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1252   VisitCXXConstructExpr(E);
1253   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1254   Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1255 }
1256
1257 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1258   VisitExpr(E);
1259   Record.push_back(E->NumCaptures);
1260   Record.AddSourceRange(E->IntroducerRange);
1261   Record.push_back(E->CaptureDefault); // FIXME: stable encoding
1262   Record.AddSourceLocation(E->CaptureDefaultLoc);
1263   Record.push_back(E->ExplicitParams);
1264   Record.push_back(E->ExplicitResultType);
1265   Record.AddSourceLocation(E->ClosingBrace);
1266
1267   // Add capture initializers.
1268   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1269                                       CEnd = E->capture_init_end();
1270        C != CEnd; ++C) {
1271     Record.AddStmt(*C);
1272   }
1273
1274   Code = serialization::EXPR_LAMBDA;
1275 }
1276
1277 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1278   VisitExpr(E);
1279   Record.AddStmt(E->getSubExpr());
1280   Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST;
1281 }
1282
1283 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1284   VisitExplicitCastExpr(E);
1285   Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()));
1286   Record.AddSourceRange(E->getAngleBrackets());
1287 }
1288
1289 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1290   VisitCXXNamedCastExpr(E);
1291   Code = serialization::EXPR_CXX_STATIC_CAST;
1292 }
1293
1294 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1295   VisitCXXNamedCastExpr(E);
1296   Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1297 }
1298
1299 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1300   VisitCXXNamedCastExpr(E);
1301   Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1302 }
1303
1304 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1305   VisitCXXNamedCastExpr(E);
1306   Code = serialization::EXPR_CXX_CONST_CAST;
1307 }
1308
1309 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1310   VisitExplicitCastExpr(E);
1311   Record.AddSourceLocation(E->getLParenLoc());
1312   Record.AddSourceLocation(E->getRParenLoc());
1313   Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1314 }
1315
1316 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1317   VisitCallExpr(E);
1318   Record.AddSourceLocation(E->UDSuffixLoc);
1319   Code = serialization::EXPR_USER_DEFINED_LITERAL;
1320 }
1321
1322 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1323   VisitExpr(E);
1324   Record.push_back(E->getValue());
1325   Record.AddSourceLocation(E->getLocation());
1326   Code = serialization::EXPR_CXX_BOOL_LITERAL;
1327 }
1328
1329 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1330   VisitExpr(E);
1331   Record.AddSourceLocation(E->getLocation());
1332   Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1333 }
1334
1335 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1336   VisitExpr(E);
1337   Record.AddSourceRange(E->getSourceRange());
1338   if (E->isTypeOperand()) {
1339     Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
1340     Code = serialization::EXPR_CXX_TYPEID_TYPE;
1341   } else {
1342     Record.AddStmt(E->getExprOperand());
1343     Code = serialization::EXPR_CXX_TYPEID_EXPR;
1344   }
1345 }
1346
1347 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1348   VisitExpr(E);
1349   Record.AddSourceLocation(E->getLocation());
1350   Record.push_back(E->isImplicit());
1351   Code = serialization::EXPR_CXX_THIS;
1352 }
1353
1354 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1355   VisitExpr(E);
1356   Record.AddSourceLocation(E->getThrowLoc());
1357   Record.AddStmt(E->getSubExpr());
1358   Record.push_back(E->isThrownVariableInScope());
1359   Code = serialization::EXPR_CXX_THROW;
1360 }
1361
1362 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1363   VisitExpr(E);
1364   Record.AddDeclRef(E->getParam());
1365   Record.AddSourceLocation(E->getUsedLocation());
1366   Code = serialization::EXPR_CXX_DEFAULT_ARG;
1367 }
1368
1369 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1370   VisitExpr(E);
1371   Record.AddDeclRef(E->getField());
1372   Record.AddSourceLocation(E->getExprLoc());
1373   Code = serialization::EXPR_CXX_DEFAULT_INIT;
1374 }
1375
1376 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1377   VisitExpr(E);
1378   Record.AddCXXTemporary(E->getTemporary());
1379   Record.AddStmt(E->getSubExpr());
1380   Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1381 }
1382
1383 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1384   VisitExpr(E);
1385   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1386   Record.AddSourceLocation(E->getRParenLoc());
1387   Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1388 }
1389
1390 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1391   VisitExpr(E);
1392   Record.push_back(E->isGlobalNew());
1393   Record.push_back(E->isArray());
1394   Record.push_back(E->passAlignment());
1395   Record.push_back(E->doesUsualArrayDeleteWantSize());
1396   Record.push_back(E->getNumPlacementArgs());
1397   Record.push_back(E->StoredInitializationStyle);
1398   Record.AddDeclRef(E->getOperatorNew());
1399   Record.AddDeclRef(E->getOperatorDelete());
1400   Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo());
1401   Record.AddSourceRange(E->getTypeIdParens());
1402   Record.AddSourceRange(E->getSourceRange());
1403   Record.AddSourceRange(E->getDirectInitRange());
1404   for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1405        I != e; ++I)
1406     Record.AddStmt(*I);
1407
1408   Code = serialization::EXPR_CXX_NEW;
1409 }
1410
1411 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1412   VisitExpr(E);
1413   Record.push_back(E->isGlobalDelete());
1414   Record.push_back(E->isArrayForm());
1415   Record.push_back(E->isArrayFormAsWritten());
1416   Record.push_back(E->doesUsualArrayDeleteWantSize());
1417   Record.AddDeclRef(E->getOperatorDelete());
1418   Record.AddStmt(E->getArgument());
1419   Record.AddSourceLocation(E->getSourceRange().getBegin());
1420
1421   Code = serialization::EXPR_CXX_DELETE;
1422 }
1423
1424 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1425   VisitExpr(E);
1426
1427   Record.AddStmt(E->getBase());
1428   Record.push_back(E->isArrow());
1429   Record.AddSourceLocation(E->getOperatorLoc());
1430   Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1431   Record.AddTypeSourceInfo(E->getScopeTypeInfo());
1432   Record.AddSourceLocation(E->getColonColonLoc());
1433   Record.AddSourceLocation(E->getTildeLoc());
1434
1435   // PseudoDestructorTypeStorage.
1436   Record.AddIdentifierRef(E->getDestroyedTypeIdentifier());
1437   if (E->getDestroyedTypeIdentifier())
1438     Record.AddSourceLocation(E->getDestroyedTypeLoc());
1439   else
1440     Record.AddTypeSourceInfo(E->getDestroyedTypeInfo());
1441
1442   Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1443 }
1444
1445 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1446   VisitExpr(E);
1447   Record.push_back(E->getNumObjects());
1448   for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i)
1449     Record.AddDeclRef(E->getObject(i));
1450
1451   Record.push_back(E->cleanupsHaveSideEffects());
1452   Record.AddStmt(E->getSubExpr());
1453   Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1454 }
1455
1456 void
1457 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1458   VisitExpr(E);
1459
1460   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1461   // emitted first.
1462
1463   Record.push_back(E->HasTemplateKWAndArgsInfo);
1464   if (E->HasTemplateKWAndArgsInfo) {
1465     const ASTTemplateKWAndArgsInfo &ArgInfo =
1466         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1467     Record.push_back(ArgInfo.NumTemplateArgs);
1468     AddTemplateKWAndArgsInfo(ArgInfo,
1469                              E->getTrailingObjects<TemplateArgumentLoc>());
1470   }
1471
1472   if (!E->isImplicitAccess())
1473     Record.AddStmt(E->getBase());
1474   else
1475     Record.AddStmt(nullptr);
1476   Record.AddTypeRef(E->getBaseType());
1477   Record.push_back(E->isArrow());
1478   Record.AddSourceLocation(E->getOperatorLoc());
1479   Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1480   Record.AddDeclRef(E->getFirstQualifierFoundInScope());
1481   Record.AddDeclarationNameInfo(E->MemberNameInfo);
1482   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1483 }
1484
1485 void
1486 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1487   VisitExpr(E);
1488
1489   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1490   // emitted first.
1491
1492   Record.push_back(E->HasTemplateKWAndArgsInfo);
1493   if (E->HasTemplateKWAndArgsInfo) {
1494     const ASTTemplateKWAndArgsInfo &ArgInfo =
1495         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1496     Record.push_back(ArgInfo.NumTemplateArgs);
1497     AddTemplateKWAndArgsInfo(ArgInfo,
1498                              E->getTrailingObjects<TemplateArgumentLoc>());
1499   }
1500
1501   Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1502   Record.AddDeclarationNameInfo(E->NameInfo);
1503   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1504 }
1505
1506 void
1507 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1508   VisitExpr(E);
1509   Record.push_back(E->arg_size());
1510   for (CXXUnresolvedConstructExpr::arg_iterator
1511          ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1512     Record.AddStmt(*ArgI);
1513   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1514   Record.AddSourceLocation(E->getLParenLoc());
1515   Record.AddSourceLocation(E->getRParenLoc());
1516   Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1517 }
1518
1519 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1520   VisitExpr(E);
1521
1522   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1523   // emitted first.
1524
1525   Record.push_back(E->HasTemplateKWAndArgsInfo);
1526   if (E->HasTemplateKWAndArgsInfo) {
1527     const ASTTemplateKWAndArgsInfo &ArgInfo =
1528         *E->getTrailingASTTemplateKWAndArgsInfo();
1529     Record.push_back(ArgInfo.NumTemplateArgs);
1530     AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
1531   }
1532
1533   Record.push_back(E->getNumDecls());
1534   for (OverloadExpr::decls_iterator
1535          OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1536     Record.AddDeclRef(OvI.getDecl());
1537     Record.push_back(OvI.getAccess());
1538   }
1539
1540   Record.AddDeclarationNameInfo(E->NameInfo);
1541   Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1542 }
1543
1544 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1545   VisitOverloadExpr(E);
1546   Record.push_back(E->isArrow());
1547   Record.push_back(E->hasUnresolvedUsing());
1548   Record.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr);
1549   Record.AddTypeRef(E->getBaseType());
1550   Record.AddSourceLocation(E->getOperatorLoc());
1551   Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1552 }
1553
1554 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1555   VisitOverloadExpr(E);
1556   Record.push_back(E->requiresADL());
1557   Record.push_back(E->isOverloaded());
1558   Record.AddDeclRef(E->getNamingClass());
1559   Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1560 }
1561
1562 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1563   VisitExpr(E);
1564   Record.push_back(E->TypeTraitExprBits.NumArgs);
1565   Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
1566   Record.push_back(E->TypeTraitExprBits.Value);
1567   Record.AddSourceRange(E->getSourceRange());
1568   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1569     Record.AddTypeSourceInfo(E->getArg(I));
1570   Code = serialization::EXPR_TYPE_TRAIT;
1571 }
1572
1573 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1574   VisitExpr(E);
1575   Record.push_back(E->getTrait());
1576   Record.push_back(E->getValue());
1577   Record.AddSourceRange(E->getSourceRange());
1578   Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo());
1579   Record.AddStmt(E->getDimensionExpression());
1580   Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1581 }
1582
1583 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1584   VisitExpr(E);
1585   Record.push_back(E->getTrait());
1586   Record.push_back(E->getValue());
1587   Record.AddSourceRange(E->getSourceRange());
1588   Record.AddStmt(E->getQueriedExpression());
1589   Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1590 }
1591
1592 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1593   VisitExpr(E);
1594   Record.push_back(E->getValue());
1595   Record.AddSourceRange(E->getSourceRange());
1596   Record.AddStmt(E->getOperand());
1597   Code = serialization::EXPR_CXX_NOEXCEPT;
1598 }
1599
1600 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1601   VisitExpr(E);
1602   Record.AddSourceLocation(E->getEllipsisLoc());
1603   Record.push_back(E->NumExpansions);
1604   Record.AddStmt(E->getPattern());
1605   Code = serialization::EXPR_PACK_EXPANSION;
1606 }
1607
1608 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1609   VisitExpr(E);
1610   Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()
1611                                                : 0);
1612   Record.AddSourceLocation(E->OperatorLoc);
1613   Record.AddSourceLocation(E->PackLoc);
1614   Record.AddSourceLocation(E->RParenLoc);
1615   Record.AddDeclRef(E->Pack);
1616   if (E->isPartiallySubstituted()) {
1617     for (const auto &TA : E->getPartialArguments())
1618       Record.AddTemplateArgument(TA);
1619   } else if (!E->isValueDependent()) {
1620     Record.push_back(E->getPackLength());
1621   }
1622   Code = serialization::EXPR_SIZEOF_PACK;
1623 }
1624
1625 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
1626                                               SubstNonTypeTemplateParmExpr *E) {
1627   VisitExpr(E);
1628   Record.AddDeclRef(E->getParameter());
1629   Record.AddSourceLocation(E->getNameLoc());
1630   Record.AddStmt(E->getReplacement());
1631   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
1632 }
1633
1634 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1635                                           SubstNonTypeTemplateParmPackExpr *E) {
1636   VisitExpr(E);
1637   Record.AddDeclRef(E->getParameterPack());
1638   Record.AddTemplateArgument(E->getArgumentPack());
1639   Record.AddSourceLocation(E->getParameterPackLocation());
1640   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
1641 }
1642
1643 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1644   VisitExpr(E);
1645   Record.push_back(E->getNumExpansions());
1646   Record.AddDeclRef(E->getParameterPack());
1647   Record.AddSourceLocation(E->getParameterPackLocation());
1648   for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
1649        I != End; ++I)
1650     Record.AddDeclRef(*I);
1651   Code = serialization::EXPR_FUNCTION_PARM_PACK;
1652 }
1653
1654 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1655   VisitExpr(E);
1656   Record.AddStmt(E->getTemporary());
1657   Record.AddDeclRef(E->getExtendingDecl());
1658   Record.push_back(E->getManglingNumber());
1659   Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
1660 }
1661
1662 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
1663   VisitExpr(E);
1664   Record.AddSourceLocation(E->LParenLoc);
1665   Record.AddSourceLocation(E->EllipsisLoc);
1666   Record.AddSourceLocation(E->RParenLoc);
1667   Record.AddStmt(E->SubExprs[0]);
1668   Record.AddStmt(E->SubExprs[1]);
1669   Record.push_back(E->Opcode);
1670   Code = serialization::EXPR_CXX_FOLD;
1671 }
1672
1673 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1674   VisitExpr(E);
1675   Record.AddStmt(E->getSourceExpr());
1676   Record.AddSourceLocation(E->getLocation());
1677   Code = serialization::EXPR_OPAQUE_VALUE;
1678 }
1679
1680 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
1681   VisitExpr(E);
1682   // TODO: Figure out sane writer behavior for a TypoExpr, if necessary
1683   llvm_unreachable("Cannot write TypoExpr nodes");
1684 }
1685
1686 //===----------------------------------------------------------------------===//
1687 // CUDA Expressions and Statements.
1688 //===----------------------------------------------------------------------===//
1689
1690 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1691   VisitCallExpr(E);
1692   Record.AddStmt(E->getConfig());
1693   Code = serialization::EXPR_CUDA_KERNEL_CALL;
1694 }
1695
1696 //===----------------------------------------------------------------------===//
1697 // OpenCL Expressions and Statements.
1698 //===----------------------------------------------------------------------===//
1699 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
1700   VisitExpr(E);
1701   Record.AddSourceLocation(E->getBuiltinLoc());
1702   Record.AddSourceLocation(E->getRParenLoc());
1703   Record.AddStmt(E->getSrcExpr());
1704   Code = serialization::EXPR_ASTYPE;
1705 }
1706
1707 //===----------------------------------------------------------------------===//
1708 // Microsoft Expressions and Statements.
1709 //===----------------------------------------------------------------------===//
1710 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1711   VisitExpr(E);
1712   Record.push_back(E->isArrow());
1713   Record.AddStmt(E->getBaseExpr());
1714   Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1715   Record.AddSourceLocation(E->getMemberLoc());
1716   Record.AddDeclRef(E->getPropertyDecl());
1717   Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR;
1718 }
1719
1720 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
1721   VisitExpr(E);
1722   Record.AddStmt(E->getBase());
1723   Record.AddStmt(E->getIdx());
1724   Record.AddSourceLocation(E->getRBracketLoc());
1725   Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR;
1726 }
1727
1728 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1729   VisitExpr(E);
1730   Record.AddSourceRange(E->getSourceRange());
1731   Record.AddString(E->getUuidStr());
1732   if (E->isTypeOperand()) {
1733     Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
1734     Code = serialization::EXPR_CXX_UUIDOF_TYPE;
1735   } else {
1736     Record.AddStmt(E->getExprOperand());
1737     Code = serialization::EXPR_CXX_UUIDOF_EXPR;
1738   }
1739 }
1740
1741 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
1742   VisitStmt(S);
1743   Record.AddSourceLocation(S->getExceptLoc());
1744   Record.AddStmt(S->getFilterExpr());
1745   Record.AddStmt(S->getBlock());
1746   Code = serialization::STMT_SEH_EXCEPT;
1747 }
1748
1749 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1750   VisitStmt(S);
1751   Record.AddSourceLocation(S->getFinallyLoc());
1752   Record.AddStmt(S->getBlock());
1753   Code = serialization::STMT_SEH_FINALLY;
1754 }
1755
1756 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
1757   VisitStmt(S);
1758   Record.push_back(S->getIsCXXTry());
1759   Record.AddSourceLocation(S->getTryLoc());
1760   Record.AddStmt(S->getTryBlock());
1761   Record.AddStmt(S->getHandler());
1762   Code = serialization::STMT_SEH_TRY;
1763 }
1764
1765 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1766   VisitStmt(S);
1767   Record.AddSourceLocation(S->getLeaveLoc());
1768   Code = serialization::STMT_SEH_LEAVE;
1769 }
1770
1771 //===----------------------------------------------------------------------===//
1772 // OpenMP Clauses.
1773 //===----------------------------------------------------------------------===//
1774
1775 namespace clang {
1776 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
1777   ASTRecordWriter &Record;
1778 public:
1779   OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {}
1780 #define OPENMP_CLAUSE(Name, Class)    \
1781   void Visit##Class(Class *S);
1782 #include "clang/Basic/OpenMPKinds.def"
1783   void writeClause(OMPClause *C);
1784   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
1785   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
1786 };
1787 }
1788
1789 void OMPClauseWriter::writeClause(OMPClause *C) {
1790   Record.push_back(C->getClauseKind());
1791   Visit(C);
1792   Record.AddSourceLocation(C->getLocStart());
1793   Record.AddSourceLocation(C->getLocEnd());
1794 }
1795
1796 void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
1797   Record.AddStmt(C->getPreInitStmt());
1798 }
1799
1800 void OMPClauseWriter::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
1801   VisitOMPClauseWithPreInit(C);
1802   Record.AddStmt(C->getPostUpdateExpr());
1803 }
1804
1805 void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) {
1806   Record.push_back(C->getNameModifier());
1807   Record.AddSourceLocation(C->getNameModifierLoc());
1808   Record.AddSourceLocation(C->getColonLoc());
1809   Record.AddStmt(C->getCondition());
1810   Record.AddSourceLocation(C->getLParenLoc());
1811 }
1812
1813 void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) {
1814   Record.AddStmt(C->getCondition());
1815   Record.AddSourceLocation(C->getLParenLoc());
1816 }
1817
1818 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1819   Record.AddStmt(C->getNumThreads());
1820   Record.AddSourceLocation(C->getLParenLoc());
1821 }
1822
1823 void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) {
1824   Record.AddStmt(C->getSafelen());
1825   Record.AddSourceLocation(C->getLParenLoc());
1826 }
1827
1828 void OMPClauseWriter::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
1829   Record.AddStmt(C->getSimdlen());
1830   Record.AddSourceLocation(C->getLParenLoc());
1831 }
1832
1833 void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) {
1834   Record.AddStmt(C->getNumForLoops());
1835   Record.AddSourceLocation(C->getLParenLoc());
1836 }
1837
1838 void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) {
1839   Record.push_back(C->getDefaultKind());
1840   Record.AddSourceLocation(C->getLParenLoc());
1841   Record.AddSourceLocation(C->getDefaultKindKwLoc());
1842 }
1843
1844 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) {
1845   Record.push_back(C->getProcBindKind());
1846   Record.AddSourceLocation(C->getLParenLoc());
1847   Record.AddSourceLocation(C->getProcBindKindKwLoc());
1848 }
1849
1850 void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) {
1851   VisitOMPClauseWithPreInit(C);
1852   Record.push_back(C->getScheduleKind());
1853   Record.push_back(C->getFirstScheduleModifier());
1854   Record.push_back(C->getSecondScheduleModifier());
1855   Record.AddStmt(C->getChunkSize());
1856   Record.AddSourceLocation(C->getLParenLoc());
1857   Record.AddSourceLocation(C->getFirstScheduleModifierLoc());
1858   Record.AddSourceLocation(C->getSecondScheduleModifierLoc());
1859   Record.AddSourceLocation(C->getScheduleKindLoc());
1860   Record.AddSourceLocation(C->getCommaLoc());
1861 }
1862
1863 void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *C) {
1864   Record.AddStmt(C->getNumForLoops());
1865   Record.AddSourceLocation(C->getLParenLoc());
1866 }
1867
1868 void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {}
1869
1870 void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {}
1871
1872 void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {}
1873
1874 void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {}
1875
1876 void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {}
1877
1878 void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *) {}
1879
1880 void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {}
1881
1882 void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
1883
1884 void OMPClauseWriter::VisitOMPThreadsClause(OMPThreadsClause *) {}
1885
1886 void OMPClauseWriter::VisitOMPSIMDClause(OMPSIMDClause *) {}
1887
1888 void OMPClauseWriter::VisitOMPNogroupClause(OMPNogroupClause *) {}
1889
1890 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) {
1891   Record.push_back(C->varlist_size());
1892   Record.AddSourceLocation(C->getLParenLoc());
1893   for (auto *VE : C->varlists()) {
1894     Record.AddStmt(VE);
1895   }
1896   for (auto *VE : C->private_copies()) {
1897     Record.AddStmt(VE);
1898   }
1899 }
1900
1901 void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
1902   Record.push_back(C->varlist_size());
1903   VisitOMPClauseWithPreInit(C);
1904   Record.AddSourceLocation(C->getLParenLoc());
1905   for (auto *VE : C->varlists()) {
1906     Record.AddStmt(VE);
1907   }
1908   for (auto *VE : C->private_copies()) {
1909     Record.AddStmt(VE);
1910   }
1911   for (auto *VE : C->inits()) {
1912     Record.AddStmt(VE);
1913   }
1914 }
1915
1916 void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
1917   Record.push_back(C->varlist_size());
1918   VisitOMPClauseWithPostUpdate(C);
1919   Record.AddSourceLocation(C->getLParenLoc());
1920   for (auto *VE : C->varlists())
1921     Record.AddStmt(VE);
1922   for (auto *E : C->private_copies())
1923     Record.AddStmt(E);
1924   for (auto *E : C->source_exprs())
1925     Record.AddStmt(E);
1926   for (auto *E : C->destination_exprs())
1927     Record.AddStmt(E);
1928   for (auto *E : C->assignment_ops())
1929     Record.AddStmt(E);
1930 }
1931
1932 void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) {
1933   Record.push_back(C->varlist_size());
1934   Record.AddSourceLocation(C->getLParenLoc());
1935   for (auto *VE : C->varlists())
1936     Record.AddStmt(VE);
1937 }
1938
1939 void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) {
1940   Record.push_back(C->varlist_size());
1941   VisitOMPClauseWithPostUpdate(C);
1942   Record.AddSourceLocation(C->getLParenLoc());
1943   Record.AddSourceLocation(C->getColonLoc());
1944   Record.AddNestedNameSpecifierLoc(C->getQualifierLoc());
1945   Record.AddDeclarationNameInfo(C->getNameInfo());
1946   for (auto *VE : C->varlists())
1947     Record.AddStmt(VE);
1948   for (auto *VE : C->privates())
1949     Record.AddStmt(VE);
1950   for (auto *E : C->lhs_exprs())
1951     Record.AddStmt(E);
1952   for (auto *E : C->rhs_exprs())
1953     Record.AddStmt(E);
1954   for (auto *E : C->reduction_ops())
1955     Record.AddStmt(E);
1956 }
1957
1958 void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) {
1959   Record.push_back(C->varlist_size());
1960   VisitOMPClauseWithPostUpdate(C);
1961   Record.AddSourceLocation(C->getLParenLoc());
1962   Record.AddSourceLocation(C->getColonLoc());
1963   Record.push_back(C->getModifier());
1964   Record.AddSourceLocation(C->getModifierLoc());
1965   for (auto *VE : C->varlists()) {
1966     Record.AddStmt(VE);
1967   }
1968   for (auto *VE : C->privates()) {
1969     Record.AddStmt(VE);
1970   }
1971   for (auto *VE : C->inits()) {
1972     Record.AddStmt(VE);
1973   }
1974   for (auto *VE : C->updates()) {
1975     Record.AddStmt(VE);
1976   }
1977   for (auto *VE : C->finals()) {
1978     Record.AddStmt(VE);
1979   }
1980   Record.AddStmt(C->getStep());
1981   Record.AddStmt(C->getCalcStep());
1982 }
1983
1984 void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) {
1985   Record.push_back(C->varlist_size());
1986   Record.AddSourceLocation(C->getLParenLoc());
1987   Record.AddSourceLocation(C->getColonLoc());
1988   for (auto *VE : C->varlists())
1989     Record.AddStmt(VE);
1990   Record.AddStmt(C->getAlignment());
1991 }
1992
1993 void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) {
1994   Record.push_back(C->varlist_size());
1995   Record.AddSourceLocation(C->getLParenLoc());
1996   for (auto *VE : C->varlists())
1997     Record.AddStmt(VE);
1998   for (auto *E : C->source_exprs())
1999     Record.AddStmt(E);
2000   for (auto *E : C->destination_exprs())
2001     Record.AddStmt(E);
2002   for (auto *E : C->assignment_ops())
2003     Record.AddStmt(E);
2004 }
2005
2006 void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
2007   Record.push_back(C->varlist_size());
2008   Record.AddSourceLocation(C->getLParenLoc());
2009   for (auto *VE : C->varlists())
2010     Record.AddStmt(VE);
2011   for (auto *E : C->source_exprs())
2012     Record.AddStmt(E);
2013   for (auto *E : C->destination_exprs())
2014     Record.AddStmt(E);
2015   for (auto *E : C->assignment_ops())
2016     Record.AddStmt(E);
2017 }
2018
2019 void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) {
2020   Record.push_back(C->varlist_size());
2021   Record.AddSourceLocation(C->getLParenLoc());
2022   for (auto *VE : C->varlists())
2023     Record.AddStmt(VE);
2024 }
2025
2026 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) {
2027   Record.push_back(C->varlist_size());
2028   Record.AddSourceLocation(C->getLParenLoc());
2029   Record.push_back(C->getDependencyKind());
2030   Record.AddSourceLocation(C->getDependencyLoc());
2031   Record.AddSourceLocation(C->getColonLoc());
2032   for (auto *VE : C->varlists())
2033     Record.AddStmt(VE);
2034   Record.AddStmt(C->getCounterValue());
2035 }
2036
2037 void OMPClauseWriter::VisitOMPDeviceClause(OMPDeviceClause *C) {
2038   Record.AddStmt(C->getDevice());
2039   Record.AddSourceLocation(C->getLParenLoc());
2040 }
2041
2042 void OMPClauseWriter::VisitOMPMapClause(OMPMapClause *C) {
2043   Record.push_back(C->varlist_size());
2044   Record.push_back(C->getUniqueDeclarationsNum());
2045   Record.push_back(C->getTotalComponentListNum());
2046   Record.push_back(C->getTotalComponentsNum());
2047   Record.AddSourceLocation(C->getLParenLoc());
2048   Record.push_back(C->getMapTypeModifier());
2049   Record.push_back(C->getMapType());
2050   Record.AddSourceLocation(C->getMapLoc());
2051   Record.AddSourceLocation(C->getColonLoc());
2052   for (auto *E : C->varlists())
2053     Record.AddStmt(E);
2054   for (auto *D : C->all_decls())
2055     Record.AddDeclRef(D);
2056   for (auto N : C->all_num_lists())
2057     Record.push_back(N);
2058   for (auto N : C->all_lists_sizes())
2059     Record.push_back(N);
2060   for (auto &M : C->all_components()) {
2061     Record.AddStmt(M.getAssociatedExpression());
2062     Record.AddDeclRef(M.getAssociatedDeclaration());
2063   }
2064 }
2065
2066 void OMPClauseWriter::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
2067   Record.AddStmt(C->getNumTeams());
2068   Record.AddSourceLocation(C->getLParenLoc());
2069 }
2070
2071 void OMPClauseWriter::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
2072   Record.AddStmt(C->getThreadLimit());
2073   Record.AddSourceLocation(C->getLParenLoc());
2074 }
2075
2076 void OMPClauseWriter::VisitOMPPriorityClause(OMPPriorityClause *C) {
2077   Record.AddStmt(C->getPriority());
2078   Record.AddSourceLocation(C->getLParenLoc());
2079 }
2080
2081 void OMPClauseWriter::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
2082   Record.AddStmt(C->getGrainsize());
2083   Record.AddSourceLocation(C->getLParenLoc());
2084 }
2085
2086 void OMPClauseWriter::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
2087   Record.AddStmt(C->getNumTasks());
2088   Record.AddSourceLocation(C->getLParenLoc());
2089 }
2090
2091 void OMPClauseWriter::VisitOMPHintClause(OMPHintClause *C) {
2092   Record.AddStmt(C->getHint());
2093   Record.AddSourceLocation(C->getLParenLoc());
2094 }
2095
2096 void OMPClauseWriter::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
2097   VisitOMPClauseWithPreInit(C);
2098   Record.push_back(C->getDistScheduleKind());
2099   Record.AddStmt(C->getChunkSize());
2100   Record.AddSourceLocation(C->getLParenLoc());
2101   Record.AddSourceLocation(C->getDistScheduleKindLoc());
2102   Record.AddSourceLocation(C->getCommaLoc());
2103 }
2104
2105 void OMPClauseWriter::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
2106   Record.push_back(C->getDefaultmapKind());
2107   Record.push_back(C->getDefaultmapModifier());
2108   Record.AddSourceLocation(C->getLParenLoc());
2109   Record.AddSourceLocation(C->getDefaultmapModifierLoc());
2110   Record.AddSourceLocation(C->getDefaultmapKindLoc());
2111 }
2112
2113 void OMPClauseWriter::VisitOMPToClause(OMPToClause *C) {
2114   Record.push_back(C->varlist_size());
2115   Record.push_back(C->getUniqueDeclarationsNum());
2116   Record.push_back(C->getTotalComponentListNum());
2117   Record.push_back(C->getTotalComponentsNum());
2118   Record.AddSourceLocation(C->getLParenLoc());
2119   for (auto *E : C->varlists())
2120     Record.AddStmt(E);
2121   for (auto *D : C->all_decls())
2122     Record.AddDeclRef(D);
2123   for (auto N : C->all_num_lists())
2124     Record.push_back(N);
2125   for (auto N : C->all_lists_sizes())
2126     Record.push_back(N);
2127   for (auto &M : C->all_components()) {
2128     Record.AddStmt(M.getAssociatedExpression());
2129     Record.AddDeclRef(M.getAssociatedDeclaration());
2130   }
2131 }
2132
2133 void OMPClauseWriter::VisitOMPFromClause(OMPFromClause *C) {
2134   Record.push_back(C->varlist_size());
2135   Record.push_back(C->getUniqueDeclarationsNum());
2136   Record.push_back(C->getTotalComponentListNum());
2137   Record.push_back(C->getTotalComponentsNum());
2138   Record.AddSourceLocation(C->getLParenLoc());
2139   for (auto *E : C->varlists())
2140     Record.AddStmt(E);
2141   for (auto *D : C->all_decls())
2142     Record.AddDeclRef(D);
2143   for (auto N : C->all_num_lists())
2144     Record.push_back(N);
2145   for (auto N : C->all_lists_sizes())
2146     Record.push_back(N);
2147   for (auto &M : C->all_components()) {
2148     Record.AddStmt(M.getAssociatedExpression());
2149     Record.AddDeclRef(M.getAssociatedDeclaration());
2150   }
2151 }
2152
2153 void OMPClauseWriter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
2154   Record.push_back(C->varlist_size());
2155   Record.push_back(C->getUniqueDeclarationsNum());
2156   Record.push_back(C->getTotalComponentListNum());
2157   Record.push_back(C->getTotalComponentsNum());
2158   Record.AddSourceLocation(C->getLParenLoc());
2159   for (auto *E : C->varlists())
2160     Record.AddStmt(E);
2161   for (auto *VE : C->private_copies())
2162     Record.AddStmt(VE);
2163   for (auto *VE : C->inits())
2164     Record.AddStmt(VE);
2165   for (auto *D : C->all_decls())
2166     Record.AddDeclRef(D);
2167   for (auto N : C->all_num_lists())
2168     Record.push_back(N);
2169   for (auto N : C->all_lists_sizes())
2170     Record.push_back(N);
2171   for (auto &M : C->all_components()) {
2172     Record.AddStmt(M.getAssociatedExpression());
2173     Record.AddDeclRef(M.getAssociatedDeclaration());
2174   }
2175 }
2176
2177 void OMPClauseWriter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
2178   Record.push_back(C->varlist_size());
2179   Record.push_back(C->getUniqueDeclarationsNum());
2180   Record.push_back(C->getTotalComponentListNum());
2181   Record.push_back(C->getTotalComponentsNum());
2182   Record.AddSourceLocation(C->getLParenLoc());
2183   for (auto *E : C->varlists())
2184     Record.AddStmt(E);
2185   for (auto *D : C->all_decls())
2186     Record.AddDeclRef(D);
2187   for (auto N : C->all_num_lists())
2188     Record.push_back(N);
2189   for (auto N : C->all_lists_sizes())
2190     Record.push_back(N);
2191   for (auto &M : C->all_components()) {
2192     Record.AddStmt(M.getAssociatedExpression());
2193     Record.AddDeclRef(M.getAssociatedDeclaration());
2194   }
2195 }
2196
2197 //===----------------------------------------------------------------------===//
2198 // OpenMP Directives.
2199 //===----------------------------------------------------------------------===//
2200 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2201   Record.AddSourceLocation(E->getLocStart());
2202   Record.AddSourceLocation(E->getLocEnd());
2203   OMPClauseWriter ClauseWriter(Record);
2204   for (unsigned i = 0; i < E->getNumClauses(); ++i) {
2205     ClauseWriter.writeClause(E->getClause(i));
2206   }
2207   if (E->hasAssociatedStmt())
2208     Record.AddStmt(E->getAssociatedStmt());
2209 }
2210
2211 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
2212   VisitStmt(D);
2213   Record.push_back(D->getNumClauses());
2214   Record.push_back(D->getCollapsedNumber());
2215   VisitOMPExecutableDirective(D);
2216   Record.AddStmt(D->getIterationVariable());
2217   Record.AddStmt(D->getLastIteration());
2218   Record.AddStmt(D->getCalcLastIteration());
2219   Record.AddStmt(D->getPreCond());
2220   Record.AddStmt(D->getCond());
2221   Record.AddStmt(D->getInit());
2222   Record.AddStmt(D->getInc());
2223   Record.AddStmt(D->getPreInits());
2224   if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
2225       isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
2226       isOpenMPDistributeDirective(D->getDirectiveKind())) {
2227     Record.AddStmt(D->getIsLastIterVariable());
2228     Record.AddStmt(D->getLowerBoundVariable());
2229     Record.AddStmt(D->getUpperBoundVariable());
2230     Record.AddStmt(D->getStrideVariable());
2231     Record.AddStmt(D->getEnsureUpperBound());
2232     Record.AddStmt(D->getNextLowerBound());
2233     Record.AddStmt(D->getNextUpperBound());
2234     Record.AddStmt(D->getNumIterations());
2235   }
2236   if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
2237     Record.AddStmt(D->getPrevLowerBoundVariable());
2238     Record.AddStmt(D->getPrevUpperBoundVariable());
2239   }
2240   for (auto I : D->counters()) {
2241     Record.AddStmt(I);
2242   }
2243   for (auto I : D->private_counters()) {
2244     Record.AddStmt(I);
2245   }
2246   for (auto I : D->inits()) {
2247     Record.AddStmt(I);
2248   }
2249   for (auto I : D->updates()) {
2250     Record.AddStmt(I);
2251   }
2252   for (auto I : D->finals()) {
2253     Record.AddStmt(I);
2254   }
2255 }
2256
2257 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
2258   VisitStmt(D);
2259   Record.push_back(D->getNumClauses());
2260   VisitOMPExecutableDirective(D);
2261   Record.push_back(D->hasCancel() ? 1 : 0);
2262   Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
2263 }
2264
2265 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
2266   VisitOMPLoopDirective(D);
2267   Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
2268 }
2269
2270 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
2271   VisitOMPLoopDirective(D);
2272   Record.push_back(D->hasCancel() ? 1 : 0);
2273   Code = serialization::STMT_OMP_FOR_DIRECTIVE;
2274 }
2275
2276 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2277   VisitOMPLoopDirective(D);
2278   Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE;
2279 }
2280
2281 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2282   VisitStmt(D);
2283   Record.push_back(D->getNumClauses());
2284   VisitOMPExecutableDirective(D);
2285   Record.push_back(D->hasCancel() ? 1 : 0);
2286   Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
2287 }
2288
2289 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
2290   VisitStmt(D);
2291   VisitOMPExecutableDirective(D);
2292   Record.push_back(D->hasCancel() ? 1 : 0);
2293   Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
2294 }
2295
2296 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
2297   VisitStmt(D);
2298   Record.push_back(D->getNumClauses());
2299   VisitOMPExecutableDirective(D);
2300   Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
2301 }
2302
2303 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
2304   VisitStmt(D);
2305   VisitOMPExecutableDirective(D);
2306   Code = serialization::STMT_OMP_MASTER_DIRECTIVE;
2307 }
2308
2309 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2310   VisitStmt(D);
2311   Record.push_back(D->getNumClauses());
2312   VisitOMPExecutableDirective(D);
2313   Record.AddDeclarationNameInfo(D->getDirectiveName());
2314   Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
2315 }
2316
2317 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2318   VisitOMPLoopDirective(D);
2319   Record.push_back(D->hasCancel() ? 1 : 0);
2320   Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
2321 }
2322
2323 void ASTStmtWriter::VisitOMPParallelForSimdDirective(
2324     OMPParallelForSimdDirective *D) {
2325   VisitOMPLoopDirective(D);
2326   Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
2327 }
2328
2329 void ASTStmtWriter::VisitOMPParallelSectionsDirective(
2330     OMPParallelSectionsDirective *D) {
2331   VisitStmt(D);
2332   Record.push_back(D->getNumClauses());
2333   VisitOMPExecutableDirective(D);
2334   Record.push_back(D->hasCancel() ? 1 : 0);
2335   Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
2336 }
2337
2338 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
2339   VisitStmt(D);
2340   Record.push_back(D->getNumClauses());
2341   VisitOMPExecutableDirective(D);
2342   Record.push_back(D->hasCancel() ? 1 : 0);
2343   Code = serialization::STMT_OMP_TASK_DIRECTIVE;
2344 }
2345
2346 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2347   VisitStmt(D);
2348   Record.push_back(D->getNumClauses());
2349   VisitOMPExecutableDirective(D);
2350   Record.AddStmt(D->getX());
2351   Record.AddStmt(D->getV());
2352   Record.AddStmt(D->getExpr());
2353   Record.AddStmt(D->getUpdateExpr());
2354   Record.push_back(D->isXLHSInRHSPart() ? 1 : 0);
2355   Record.push_back(D->isPostfixUpdate() ? 1 : 0);
2356   Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
2357 }
2358
2359 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
2360   VisitStmt(D);
2361   Record.push_back(D->getNumClauses());
2362   VisitOMPExecutableDirective(D);
2363   Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
2364 }
2365
2366 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2367   VisitStmt(D);
2368   Record.push_back(D->getNumClauses());
2369   VisitOMPExecutableDirective(D);
2370   Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE;
2371 }
2372
2373 void ASTStmtWriter::VisitOMPTargetEnterDataDirective(
2374     OMPTargetEnterDataDirective *D) {
2375   VisitStmt(D);
2376   Record.push_back(D->getNumClauses());
2377   VisitOMPExecutableDirective(D);
2378   Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE;
2379 }
2380
2381 void ASTStmtWriter::VisitOMPTargetExitDataDirective(
2382     OMPTargetExitDataDirective *D) {
2383   VisitStmt(D);
2384   Record.push_back(D->getNumClauses());
2385   VisitOMPExecutableDirective(D);
2386   Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE;
2387 }
2388
2389 void ASTStmtWriter::VisitOMPTargetParallelDirective(
2390     OMPTargetParallelDirective *D) {
2391   VisitStmt(D);
2392   Record.push_back(D->getNumClauses());
2393   VisitOMPExecutableDirective(D);
2394   Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE;
2395 }
2396
2397 void ASTStmtWriter::VisitOMPTargetParallelForDirective(
2398     OMPTargetParallelForDirective *D) {
2399   VisitOMPLoopDirective(D);
2400   Record.push_back(D->hasCancel() ? 1 : 0);
2401   Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE;
2402 }
2403
2404 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2405   VisitStmt(D);
2406   VisitOMPExecutableDirective(D);
2407   Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
2408 }
2409
2410 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2411   VisitStmt(D);
2412   VisitOMPExecutableDirective(D);
2413   Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
2414 }
2415
2416 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2417   VisitStmt(D);
2418   VisitOMPExecutableDirective(D);
2419   Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
2420 }
2421
2422 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2423   VisitStmt(D);
2424   VisitOMPExecutableDirective(D);
2425   Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE;
2426 }
2427
2428 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
2429   VisitStmt(D);
2430   Record.push_back(D->getNumClauses());
2431   VisitOMPExecutableDirective(D);
2432   Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
2433 }
2434
2435 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2436   VisitStmt(D);
2437   Record.push_back(D->getNumClauses());
2438   VisitOMPExecutableDirective(D);
2439   Code = serialization::STMT_OMP_ORDERED_DIRECTIVE;
2440 }
2441
2442 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2443   VisitStmt(D);
2444   Record.push_back(D->getNumClauses());
2445   VisitOMPExecutableDirective(D);
2446   Code = serialization::STMT_OMP_TEAMS_DIRECTIVE;
2447 }
2448
2449 void ASTStmtWriter::VisitOMPCancellationPointDirective(
2450     OMPCancellationPointDirective *D) {
2451   VisitStmt(D);
2452   VisitOMPExecutableDirective(D);
2453   Record.push_back(D->getCancelRegion());
2454   Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
2455 }
2456
2457 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
2458   VisitStmt(D);
2459   Record.push_back(D->getNumClauses());
2460   VisitOMPExecutableDirective(D);
2461   Record.push_back(D->getCancelRegion());
2462   Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
2463 }
2464
2465 void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2466   VisitOMPLoopDirective(D);
2467   Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE;
2468 }
2469
2470 void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2471   VisitOMPLoopDirective(D);
2472   Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE;
2473 }
2474
2475 void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2476   VisitOMPLoopDirective(D);
2477   Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE;
2478 }
2479
2480 void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2481   VisitStmt(D);
2482   Record.push_back(D->getNumClauses());
2483   VisitOMPExecutableDirective(D);
2484   Code = serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE;
2485 }
2486
2487 void ASTStmtWriter::VisitOMPDistributeParallelForDirective(
2488     OMPDistributeParallelForDirective *D) {
2489   VisitOMPLoopDirective(D);
2490   Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2491 }
2492
2493 void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective(
2494     OMPDistributeParallelForSimdDirective *D) {
2495   VisitOMPLoopDirective(D);
2496   Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2497 }
2498
2499 void ASTStmtWriter::VisitOMPDistributeSimdDirective(
2500     OMPDistributeSimdDirective *D) {
2501   VisitOMPLoopDirective(D);
2502   Code = serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE;
2503 }
2504
2505 void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective(
2506     OMPTargetParallelForSimdDirective *D) {
2507   VisitOMPLoopDirective(D);
2508   Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE;
2509 }
2510
2511 void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2512   VisitOMPLoopDirective(D);
2513   Code = serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE;
2514 }
2515
2516 void ASTStmtWriter::VisitOMPTeamsDistributeDirective(
2517     OMPTeamsDistributeDirective *D) {
2518   VisitOMPLoopDirective(D);
2519   Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE;
2520 }
2521
2522 void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective(
2523     OMPTeamsDistributeSimdDirective *D) {
2524   VisitOMPLoopDirective(D);
2525   Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
2526 }
2527
2528 void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective(
2529     OMPTeamsDistributeParallelForSimdDirective *D) {
2530   VisitOMPLoopDirective(D);
2531   Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2532 }
2533
2534 void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective(
2535     OMPTeamsDistributeParallelForDirective *D) {
2536   VisitOMPLoopDirective(D);
2537   Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2538 }
2539
2540 void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2541   VisitStmt(D);
2542   Record.push_back(D->getNumClauses());
2543   VisitOMPExecutableDirective(D);
2544   Code = serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE;
2545 }
2546
2547 void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective(
2548     OMPTargetTeamsDistributeDirective *D) {
2549   VisitOMPLoopDirective(D);
2550   Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE;
2551 }
2552
2553 void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective(
2554     OMPTargetTeamsDistributeParallelForDirective *D) {
2555   VisitOMPLoopDirective(D);
2556   Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2557 }
2558
2559 //===----------------------------------------------------------------------===//
2560 // ASTWriter Implementation
2561 //===----------------------------------------------------------------------===//
2562
2563 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
2564   assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
2565          "SwitchCase recorded twice");
2566   unsigned NextID = SwitchCaseIDs.size();
2567   SwitchCaseIDs[S] = NextID;
2568   return NextID;
2569 }
2570
2571 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
2572   assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
2573          "SwitchCase hasn't been seen yet");
2574   return SwitchCaseIDs[S];
2575 }
2576
2577 void ASTWriter::ClearSwitchCaseIDs() {
2578   SwitchCaseIDs.clear();
2579 }
2580
2581 /// \brief Write the given substatement or subexpression to the
2582 /// bitstream.
2583 void ASTWriter::WriteSubStmt(Stmt *S) {
2584   RecordData Record;
2585   ASTStmtWriter Writer(*this, Record);
2586   ++NumStatements;
2587
2588   if (!S) {
2589     Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
2590     return;
2591   }
2592
2593   llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
2594   if (I != SubStmtEntries.end()) {
2595     Record.push_back(I->second);
2596     Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
2597     return;
2598   }
2599
2600 #ifndef NDEBUG
2601   assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
2602
2603   struct ParentStmtInserterRAII {
2604     Stmt *S;
2605     llvm::DenseSet<Stmt *> &ParentStmts;
2606
2607     ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
2608       : S(S), ParentStmts(ParentStmts) {
2609       ParentStmts.insert(S);
2610     }
2611     ~ParentStmtInserterRAII() {
2612       ParentStmts.erase(S);
2613     }
2614   };
2615
2616   ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
2617 #endif
2618
2619   Writer.Visit(S);
2620
2621   uint64_t Offset = Writer.Emit();
2622   SubStmtEntries[S] = Offset;
2623 }
2624
2625 /// \brief Flush all of the statements that have been added to the
2626 /// queue via AddStmt().
2627 void ASTRecordWriter::FlushStmts() {
2628   // We expect to be the only consumer of the two temporary statement maps,
2629   // assert that they are empty.
2630   assert(Writer->SubStmtEntries.empty() && "unexpected entries in sub-stmt map");
2631   assert(Writer->ParentStmts.empty() && "unexpected entries in parent stmt map");
2632
2633   for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2634     Writer->WriteSubStmt(StmtsToEmit[I]);
2635
2636     assert(N == StmtsToEmit.size() && "record modified while being written!");
2637
2638     // Note that we are at the end of a full expression. Any
2639     // expression records that follow this one are part of a different
2640     // expression.
2641     Writer->Stream.EmitRecord(serialization::STMT_STOP, ArrayRef<uint32_t>());
2642
2643     Writer->SubStmtEntries.clear();
2644     Writer->ParentStmts.clear();
2645   }
2646
2647   StmtsToEmit.clear();
2648 }
2649
2650 void ASTRecordWriter::FlushSubStmts() {
2651   // For a nested statement, write out the substatements in reverse order (so
2652   // that a simple stack machine can be used when loading), and don't emit a
2653   // STMT_STOP after each one.
2654   for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2655     Writer->WriteSubStmt(StmtsToEmit[N - I - 1]);
2656     assert(N == StmtsToEmit.size() && "record modified while being written!");
2657   }
2658
2659   StmtsToEmit.clear();
2660 }