/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp

Bug Summary

File:	tools/clang/lib/Serialization/ASTReaderStmt.cpp
Warning:	line 600, column 17 Array access (via field 'Exprs') results in a null pointer dereference
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ASTReaderStmt.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/lib/Serialization -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp -faddrsig
1//===- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------------------===//
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// Statement/expression deserialization.  This implements the
11// ASTReader::ReadStmt method.
12//
13//===----------------------------------------------------------------------===//

15#include "clang/Serialization/ASTReader.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/AttrIterator.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclAccessPair.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclGroup.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/DeclTemplate.h"
24#include "clang/AST/DeclarationName.h"
25#include "clang/AST/Expr.h"
26#include "clang/AST/ExprCXX.h"
27#include "clang/AST/ExprObjC.h"
28#include "clang/AST/ExprOpenMP.h"
29#include "clang/AST/NestedNameSpecifier.h"
30#include "clang/AST/OpenMPClause.h"
31#include "clang/AST/OperationKinds.h"
32#include "clang/AST/Stmt.h"
33#include "clang/AST/StmtCXX.h"
34#include "clang/AST/StmtObjC.h"
35#include "clang/AST/StmtOpenMP.h"
36#include "clang/AST/StmtVisitor.h"
37#include "clang/AST/TemplateBase.h"
38#include "clang/AST/Type.h"
39#include "clang/AST/UnresolvedSet.h"
40#include "clang/Basic/CapturedStmt.h"
41#include "clang/Basic/ExpressionTraits.h"
42#include "clang/Basic/LLVM.h"
43#include "clang/Basic/Lambda.h"
44#include "clang/Basic/LangOptions.h"
45#include "clang/Basic/OpenMPKinds.h"
46#include "clang/Basic/OperatorKinds.h"
47#include "clang/Basic/SourceLocation.h"
48#include "clang/Basic/Specifiers.h"
49#include "clang/Basic/TypeTraits.h"
50#include "clang/Lex/Token.h"
51#include "clang/Serialization/ASTBitCodes.h"
52#include "llvm/ADT/DenseMap.h"
53#include "llvm/ADT/SmallString.h"
54#include "llvm/ADT/SmallVector.h"
55#include "llvm/ADT/StringRef.h"
56#include "llvm/Bitcode/BitstreamReader.h"
57#include "llvm/Support/Casting.h"
58#include "llvm/Support/ErrorHandling.h"
59#include <algorithm>
60#include <cassert>
61#include <cstdint>
62#include <string>

64using namespace clang;
65using namespace serialization;

67namespace clang {

class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
  friend class OMPClauseReader;

  ASTRecordReader &Record;
  llvm::BitstreamCursor &DeclsCursor;

  SourceLocation ReadSourceLocation() {
    return Record.readSourceLocation();
  }

  SourceRange ReadSourceRange() {
    return Record.readSourceRange();
  }

  std::string ReadString() {
    return Record.readString();
  }

  TypeSourceInfo *GetTypeSourceInfo() {
    return Record.getTypeSourceInfo();
  }

  Decl *ReadDecl() {
    return Record.readDecl();
  }

  template<typename T>
  T *ReadDeclAs() {
    return Record.readDeclAs<T>();
  }

  void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc,
                              DeclarationName Name) {
    Record.readDeclarationNameLoc(DNLoc, Name);
  }

  void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo) {
    Record.readDeclarationNameInfo(NameInfo);
  }

public:
  ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
      : Record(Record), DeclsCursor(Cursor) {}

  /// The number of record fields required for the Stmt class
  /// itself.
  static const unsigned NumStmtFields = 0;

  /// The number of record fields required for the Expr class
  /// itself.
  static const unsigned NumExprFields = NumStmtFields + 7;

  /// Read and initialize a ExplicitTemplateArgumentList structure.
  void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
                                 TemplateArgumentLoc *ArgsLocArray,
                                 unsigned NumTemplateArgs);

  /// Read and initialize a ExplicitTemplateArgumentList structure.
  void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
                                        unsigned NumTemplateArgs);

  void VisitStmt(Stmt *S);
131#define STMT(Type, Base) \
  void Visit##Type(Type *);
133#include "clang/AST/StmtNodes.inc"
};

136} // namespace clang

138void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
                                            TemplateArgumentLoc *ArgsLocArray,
                                            unsigned NumTemplateArgs) {
SourceLocation TemplateKWLoc = ReadSourceLocation();
TemplateArgumentListInfo ArgInfo;
ArgInfo.setLAngleLoc(ReadSourceLocation());
ArgInfo.setRAngleLoc(ReadSourceLocation());
for (unsigned i = 0; i != NumTemplateArgs; ++i)
  ArgInfo.addArgument(Record.readTemplateArgumentLoc());
Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
148}

150void ASTStmtReader::VisitStmt(Stmt *S) {
assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count")((Record.getIdx() == NumStmtFields && "Incorrect statement field count"
) ? static_cast<void> (0) : __assert_fail ("Record.getIdx() == NumStmtFields && \"Incorrect statement field count\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 151, __PRETTY_FUNCTION__));
152}

154void ASTStmtReader::VisitNullStmt(NullStmt *S) {
VisitStmt(S);
S->setSemiLoc(ReadSourceLocation());
S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
158}

160void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
VisitStmt(S);
SmallVector<Stmt *, 16> Stmts;
unsigned NumStmts = Record.readInt();
while (NumStmts--)
  Stmts.push_back(Record.readSubStmt());
S->setStmts(Stmts);
S->CompoundStmtBits.LBraceLoc = ReadSourceLocation();
S->RBraceLoc = ReadSourceLocation();
169}

171void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
VisitStmt(S);
Record.recordSwitchCaseID(S, Record.readInt());
S->setKeywordLoc(ReadSourceLocation());
S->setColonLoc(ReadSourceLocation());
176}

178void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
VisitSwitchCase(S);
S->setLHS(Record.readSubExpr());
S->setRHS(Record.readSubExpr());
S->setSubStmt(Record.readSubStmt());
S->setEllipsisLoc(ReadSourceLocation());
184}

186void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
VisitSwitchCase(S);
S->setSubStmt(Record.readSubStmt());
189}

191void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
VisitStmt(S);
auto *LD = ReadDeclAs<LabelDecl>();
LD->setStmt(S);
S->setDecl(LD);
S->setSubStmt(Record.readSubStmt());
S->setIdentLoc(ReadSourceLocation());
198}

200void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
VisitStmt(S);
// NumAttrs in AttributedStmt is set when creating an empty
// AttributedStmt in AttributedStmt::CreateEmpty, since it is needed
// to allocate the right amount of space for the trailing Attr *.
uint64_t NumAttrs = Record.readInt();
AttrVec Attrs;
Record.readAttributes(Attrs);
(void)NumAttrs;
assert(NumAttrs == S->AttributedStmtBits.NumAttrs)((NumAttrs == S->AttributedStmtBits.NumAttrs) ? static_cast
<void> (0) : __assert_fail ("NumAttrs == S->AttributedStmtBits.NumAttrs"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 209, __PRETTY_FUNCTION__));
assert(NumAttrs == Attrs.size())((NumAttrs == Attrs.size()) ? static_cast<void> (0) : __assert_fail
 ("NumAttrs == Attrs.size()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 210, __PRETTY_FUNCTION__));
std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
S->SubStmt = Record.readSubStmt();
S->AttributedStmtBits.AttrLoc = ReadSourceLocation();
214}

216void ASTStmtReader::VisitIfStmt(IfStmt *S) {
VisitStmt(S);
S->setConstexpr(Record.readInt());
S->setInit(Record.readSubStmt());
S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
S->setCond(Record.readSubExpr());
S->setThen(Record.readSubStmt());
S->setElse(Record.readSubStmt());
S->setIfLoc(ReadSourceLocation());
S->setElseLoc(ReadSourceLocation());
226}

228void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
VisitStmt(S);
S->setInit(Record.readSubStmt());
S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
S->setCond(Record.readSubExpr());
S->setBody(Record.readSubStmt());
S->setSwitchLoc(ReadSourceLocation());
if (Record.readInt())
  S->setAllEnumCasesCovered();

SwitchCase *PrevSC = nullptr;
for (auto E = Record.size(); Record.getIdx() != E; ) {
  SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt());
  if (PrevSC)
    PrevSC->setNextSwitchCase(SC);
  else
    S->setSwitchCaseList(SC);

  PrevSC = SC;
}
248}

250void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
VisitStmt(S);
S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());

S->setCond(Record.readSubExpr());
S->setBody(Record.readSubStmt());
S->setWhileLoc(ReadSourceLocation());
257}

259void ASTStmtReader::VisitDoStmt(DoStmt *S) {
VisitStmt(S);
S->setCond(Record.readSubExpr());
S->setBody(Record.readSubStmt());
S->setDoLoc(ReadSourceLocation());
S->setWhileLoc(ReadSourceLocation());
S->setRParenLoc(ReadSourceLocation());
266}

268void ASTStmtReader::VisitForStmt(ForStmt *S) {
VisitStmt(S);
S->setInit(Record.readSubStmt());
S->setCond(Record.readSubExpr());
S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
S->setInc(Record.readSubExpr());
S->setBody(Record.readSubStmt());
S->setForLoc(ReadSourceLocation());
S->setLParenLoc(ReadSourceLocation());
S->setRParenLoc(ReadSourceLocation());
278}

280void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
VisitStmt(S);
S->setLabel(ReadDeclAs<LabelDecl>());
S->setGotoLoc(ReadSourceLocation());
S->setLabelLoc(ReadSourceLocation());
285}

287void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
VisitStmt(S);
S->setGotoLoc(ReadSourceLocation());
S->setStarLoc(ReadSourceLocation());
S->setTarget(Record.readSubExpr());
292}

294void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
VisitStmt(S);
S->setContinueLoc(ReadSourceLocation());
297}

299void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
VisitStmt(S);
S->setBreakLoc(ReadSourceLocation());
302}

304void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
VisitStmt(S);
S->setRetValue(Record.readSubExpr());
S->setReturnLoc(ReadSourceLocation());
S->setNRVOCandidate(ReadDeclAs<VarDecl>());
309}

311void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
VisitStmt(S);
S->setStartLoc(ReadSourceLocation());
S->setEndLoc(ReadSourceLocation());

if (Record.size() - Record.getIdx() == 1) {
  // Single declaration
  S->setDeclGroup(DeclGroupRef(ReadDecl()));
} else {
  SmallVector<Decl *, 16> Decls;
  int N = Record.size() - Record.getIdx();
  Decls.reserve(N);
  for (int I = 0; I < N; ++I)
    Decls.push_back(ReadDecl());
  S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(),
                                                 Decls.data(),
                                                 Decls.size())));
}
329}

331void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
VisitStmt(S);
S->NumOutputs = Record.readInt();
S->NumInputs = Record.readInt();
S->NumClobbers = Record.readInt();
S->setAsmLoc(ReadSourceLocation());
S->setVolatile(Record.readInt());
S->setSimple(Record.readInt());
339}

341void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
VisitAsmStmt(S);
S->setRParenLoc(ReadSourceLocation());
S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt()));

unsigned NumOutputs = S->getNumOutputs();
unsigned NumInputs = S->getNumInputs();
unsigned NumClobbers = S->getNumClobbers();

// Outputs and inputs
SmallVector<IdentifierInfo *, 16> Names;
SmallVector<StringLiteral*, 16> Constraints;
SmallVector<Stmt*, 16> Exprs;
for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
  Names.push_back(Record.getIdentifierInfo());
  Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
  Exprs.push_back(Record.readSubStmt());
}

// Constraints
SmallVector<StringLiteral*, 16> Clobbers;
for (unsigned I = 0; I != NumClobbers; ++I)
  Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));

S->setOutputsAndInputsAndClobbers(Record.getContext(),
                                  Names.data(), Constraints.data(),
                                  Exprs.data(), NumOutputs, NumInputs,
                                  Clobbers.data(), NumClobbers);
369}

371void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
VisitAsmStmt(S);
S->LBraceLoc = ReadSourceLocation();
S->EndLoc = ReadSourceLocation();
S->NumAsmToks = Record.readInt();
std::string AsmStr = ReadString();

// Read the tokens.
SmallVector<Token, 16> AsmToks;
AsmToks.reserve(S->NumAsmToks);
for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
  AsmToks.push_back(Record.readToken());
}

// The calls to reserve() for the FooData vectors are mandatory to
// prevent dead StringRefs in the Foo vectors.

// Read the clobbers.
SmallVector<std::string, 16> ClobbersData;
SmallVector<StringRef, 16> Clobbers;
ClobbersData.reserve(S->NumClobbers);
Clobbers.reserve(S->NumClobbers);
for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
  ClobbersData.push_back(ReadString());
  Clobbers.push_back(ClobbersData.back());
}

// Read the operands.
unsigned NumOperands = S->NumOutputs + S->NumInputs;
SmallVector<Expr*, 16> Exprs;
SmallVector<std::string, 16> ConstraintsData;
SmallVector<StringRef, 16> Constraints;
Exprs.reserve(NumOperands);
ConstraintsData.reserve(NumOperands);
Constraints.reserve(NumOperands);
for (unsigned i = 0; i != NumOperands; ++i) {
  Exprs.push_back(cast<Expr>(Record.readSubStmt()));
  ConstraintsData.push_back(ReadString());
  Constraints.push_back(ConstraintsData.back());
}

S->initialize(Record.getContext(), AsmStr, AsmToks,
              Constraints, Exprs, Clobbers);
414}

416void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
VisitStmt(S);
assert(Record.peekInt() == S->NumParams)((Record.peekInt() == S->NumParams) ? static_cast<void>
 (0) : __assert_fail ("Record.peekInt() == S->NumParams", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 418, __PRETTY_FUNCTION__));
Record.skipInts(1);
auto *StoredStmts = S->getStoredStmts();
for (unsigned i = 0;
     i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
  StoredStmts[i] = Record.readSubStmt();
424}

426void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
VisitStmt(S);
S->CoreturnLoc = Record.readSourceLocation();
for (auto &SubStmt: S->SubStmts)
  SubStmt = Record.readSubStmt();
S->IsImplicit = Record.readInt() != 0;
432}

434void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
VisitExpr(E);
E->KeywordLoc = ReadSourceLocation();
for (auto &SubExpr: E->SubExprs)
  SubExpr = Record.readSubStmt();
E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
E->setIsImplicit(Record.readInt() != 0);
441}

443void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
VisitExpr(E);
E->KeywordLoc = ReadSourceLocation();
for (auto &SubExpr: E->SubExprs)
  SubExpr = Record.readSubStmt();
E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
449}

451void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
VisitExpr(E);
E->KeywordLoc = ReadSourceLocation();
for (auto &SubExpr: E->SubExprs)
  SubExpr = Record.readSubStmt();
456}

458void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
VisitStmt(S);
Record.skipInts(1);
S->setCapturedDecl(ReadDeclAs<CapturedDecl>());
S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>());

// Capture inits
for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
                                         E = S->capture_init_end();
     I != E; ++I)
  *I = Record.readSubExpr();

// Body
S->setCapturedStmt(Record.readSubStmt());
S->getCapturedDecl()->setBody(S->getCapturedStmt());

// Captures
for (auto &I : S->captures()) {
  I.VarAndKind.setPointer(ReadDeclAs<VarDecl>());
  I.VarAndKind.setInt(
      static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
  I.Loc = ReadSourceLocation();
}
482}

484void ASTStmtReader::VisitExpr(Expr *E) {
VisitStmt(E);
E->setType(Record.readType());
E->setTypeDependent(Record.readInt());
E->setValueDependent(Record.readInt());
E->setInstantiationDependent(Record.readInt());
E->ExprBits.ContainsUnexpandedParameterPack = Record.readInt();
E->setValueKind(static_cast<ExprValueKind>(Record.readInt()));
E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt()));
assert(Record.getIdx() == NumExprFields &&((Record.getIdx() == NumExprFields && "Incorrect expression field count"
) ? static_cast<void> (0) : __assert_fail ("Record.getIdx() == NumExprFields && \"Incorrect expression field count\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 494, __PRETTY_FUNCTION__))
       "Incorrect expression field count")((Record.getIdx() == NumExprFields && "Incorrect expression field count"
) ? static_cast<void> (0) : __assert_fail ("Record.getIdx() == NumExprFields && \"Incorrect expression field count\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 494, __PRETTY_FUNCTION__));
495}

497void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
VisitExpr(E);
bool HasFunctionName = Record.readInt();
E->PredefinedExprBits.HasFunctionName = HasFunctionName;
E->PredefinedExprBits.Kind = Record.readInt();
E->setLocation(ReadSourceLocation());
if (HasFunctionName)
  E->setFunctionName(cast<StringLiteral>(Record.readSubExpr()));
505}

507void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
VisitExpr(E);

E->DeclRefExprBits.HasQualifier = Record.readInt();
E->DeclRefExprBits.HasFoundDecl = Record.readInt();
E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
unsigned NumTemplateArgs = 0;
if (E->hasTemplateKWAndArgsInfo())
  NumTemplateArgs = Record.readInt();

if (E->hasQualifier())
  new (E->getTrailingObjects<NestedNameSpecifierLoc>())
      NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());

if (E->hasFoundDecl())
  *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>();

if (E->hasTemplateKWAndArgsInfo())
  ReadTemplateKWAndArgsInfo(
      *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
      E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);

E->setDecl(ReadDeclAs<ValueDecl>());
E->setLocation(ReadSourceLocation());
ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
534}

536void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
VisitExpr(E);
E->setLocation(ReadSourceLocation());
E->setValue(Record.getContext(), Record.readAPInt());
540}

542void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
VisitExpr(E);
E->setLocation(ReadSourceLocation());
E->setValue(Record.getContext(), Record.readAPInt());
546}

548void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
VisitExpr(E);
E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record.readInt()));
E->setExact(Record.readInt());
E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
E->setLocation(ReadSourceLocation());
554}

556void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
VisitExpr(E);
E->setSubExpr(Record.readSubExpr());
559}

561void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
VisitExpr(E);
unsigned Len = Record.readInt();
assert(Record.peekInt() == E->getNumConcatenated() &&((Record.peekInt() == E->getNumConcatenated() && "Wrong number of concatenated tokens!"
) ? static_cast<void> (0) : __assert_fail ("Record.peekInt() == E->getNumConcatenated() && \"Wrong number of concatenated tokens!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 565, __PRETTY_FUNCTION__))
       "Wrong number of concatenated tokens!")((Record.peekInt() == E->getNumConcatenated() && "Wrong number of concatenated tokens!"
) ? static_cast<void> (0) : __assert_fail ("Record.peekInt() == E->getNumConcatenated() && \"Wrong number of concatenated tokens!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 565, __PRETTY_FUNCTION__));
Record.skipInts(1);
auto kind = static_cast<StringLiteral::StringKind>(Record.readInt());
bool isPascal = Record.readInt();

// Read string data
auto B = &Record.peekInt();
SmallString<16> Str(B, B + Len);
E->setString(Record.getContext(), Str, kind, isPascal);
Record.skipInts(Len);

// Read source locations
for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
  E->setStrTokenLoc(I, ReadSourceLocation());
579}

581void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
VisitExpr(E);
E->setValue(Record.readInt());
E->setLocation(ReadSourceLocation());
E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
586}

588void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
VisitExpr(E);
E->setLParen(ReadSourceLocation());
E->setRParen(ReadSourceLocation());
E->setSubExpr(Record.readSubExpr());
593}

595void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
VisitExpr(E);
unsigned NumExprs = Record.readInt();
E->Exprs = new (Record.getContext()) Stmt*[NumExprs];
1
Null pointer value stored to field 'Exprs'→
for (unsigned i = 0; i != NumExprs; ++i)
2
←
Assuming 'i' is not equal to 'NumExprs'→
3
←
Loop condition is true.  Entering loop body→
  E->Exprs[i] = Record.readSubStmt();
4
←
Array access (via field 'Exprs') results in a null pointer dereference
E->NumExprs = NumExprs;
E->LParenLoc = ReadSourceLocation();
E->RParenLoc = ReadSourceLocation();
604}

606void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
VisitExpr(E);
E->setSubExpr(Record.readSubExpr());
E->setOpcode((UnaryOperator::Opcode)Record.readInt());
E->setOperatorLoc(ReadSourceLocation());
E->setCanOverflow(Record.readInt());
612}

614void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
VisitExpr(E);
assert(E->getNumComponents() == Record.peekInt())((E->getNumComponents() == Record.peekInt()) ? static_cast
<void> (0) : __assert_fail ("E->getNumComponents() == Record.peekInt()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 616, __PRETTY_FUNCTION__));
Record.skipInts(1);
assert(E->getNumExpressions() == Record.peekInt())((E->getNumExpressions() == Record.peekInt()) ? static_cast
<void> (0) : __assert_fail ("E->getNumExpressions() == Record.peekInt()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 618, __PRETTY_FUNCTION__));
Record.skipInts(1);
E->setOperatorLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
E->setTypeSourceInfo(GetTypeSourceInfo());
for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
  auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
  SourceLocation Start = ReadSourceLocation();
  SourceLocation End = ReadSourceLocation();
  switch (Kind) {
  case OffsetOfNode::Array:
    E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
    break;

  case OffsetOfNode::Field:
    E->setComponent(
        I, OffsetOfNode(Start, ReadDeclAs<FieldDecl>(), End));
    break;

  case OffsetOfNode::Identifier:
    E->setComponent(
        I,
        OffsetOfNode(Start, Record.getIdentifierInfo(), End));
    break;

  case OffsetOfNode::Base: {
    auto *Base = new (Record.getContext()) CXXBaseSpecifier();
    *Base = Record.readCXXBaseSpecifier();
    E->setComponent(I, OffsetOfNode(Base));
    break;
  }
  }
}

for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
  E->setIndexExpr(I, Record.readSubExpr());
654}

656void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
VisitExpr(E);
E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
if (Record.peekInt() == 0) {
  E->setArgument(Record.readSubExpr());
  Record.skipInts(1);
} else {
  E->setArgument(GetTypeSourceInfo());
}
E->setOperatorLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
667}

669void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
VisitExpr(E);
E->setLHS(Record.readSubExpr());
E->setRHS(Record.readSubExpr());
E->setRBracketLoc(ReadSourceLocation());
674}

676void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
VisitExpr(E);
E->setBase(Record.readSubExpr());
E->setLowerBound(Record.readSubExpr());
E->setLength(Record.readSubExpr());
E->setColonLoc(ReadSourceLocation());
E->setRBracketLoc(ReadSourceLocation());
683}

685void ASTStmtReader::VisitCallExpr(CallExpr *E) {
VisitExpr(E);
E->setNumArgs(Record.getContext(), Record.readInt());
E->setRParenLoc(ReadSourceLocation());
E->setCallee(Record.readSubExpr());
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
  E->setArg(I, Record.readSubExpr());
692}

694void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
VisitCallExpr(E);
696}

698void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
// Don't call VisitExpr, this is fully initialized at creation.
assert(E->getStmtClass() == Stmt::MemberExprClass &&((E->getStmtClass() == Stmt::MemberExprClass && "It's a subclass, we must advance Idx!"
) ? static_cast<void> (0) : __assert_fail ("E->getStmtClass() == Stmt::MemberExprClass && \"It's a subclass, we must advance Idx!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 701, __PRETTY_FUNCTION__))
       "It's a subclass, we must advance Idx!")((E->getStmtClass() == Stmt::MemberExprClass && "It's a subclass, we must advance Idx!"
) ? static_cast<void> (0) : __assert_fail ("E->getStmtClass() == Stmt::MemberExprClass && \"It's a subclass, we must advance Idx!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 701, __PRETTY_FUNCTION__));
702}

704void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
VisitExpr(E);
E->setBase(Record.readSubExpr());
E->setIsaMemberLoc(ReadSourceLocation());
E->setOpLoc(ReadSourceLocation());
E->setArrow(Record.readInt());
710}

712void ASTStmtReader::
713VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
VisitExpr(E);
E->Operand = Record.readSubExpr();
E->setShouldCopy(Record.readInt());
717}

719void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
VisitExplicitCastExpr(E);
E->LParenLoc = ReadSourceLocation();
E->BridgeKeywordLoc = ReadSourceLocation();
E->Kind = Record.readInt();
724}

726void ASTStmtReader::VisitCastExpr(CastExpr *E) {
VisitExpr(E);
unsigned NumBaseSpecs = Record.readInt();
assert(NumBaseSpecs == E->path_size())((NumBaseSpecs == E->path_size()) ? static_cast<void>
 (0) : __assert_fail ("NumBaseSpecs == E->path_size()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 729, __PRETTY_FUNCTION__));
E->setSubExpr(Record.readSubExpr());
E->setCastKind((CastKind)Record.readInt());
CastExpr::path_iterator BaseI = E->path_begin();
while (NumBaseSpecs--) {
  auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
  *BaseSpec = Record.readCXXBaseSpecifier();
  *BaseI++ = BaseSpec;
}
738}

740void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
VisitExpr(E);
E->setLHS(Record.readSubExpr());
E->setRHS(Record.readSubExpr());
E->setOpcode((BinaryOperator::Opcode)Record.readInt());
E->setOperatorLoc(ReadSourceLocation());
E->setFPFeatures(FPOptions(Record.readInt()));
747}

749void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
VisitBinaryOperator(E);
E->setComputationLHSType(Record.readType());
E->setComputationResultType(Record.readType());
753}

755void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
VisitExpr(E);
E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
E->QuestionLoc = ReadSourceLocation();
E->ColonLoc = ReadSourceLocation();
762}

764void
765ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
VisitExpr(E);
E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
E->QuestionLoc = ReadSourceLocation();
E->ColonLoc = ReadSourceLocation();
774}

776void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
VisitCastExpr(E);
E->setIsPartOfExplicitCast(Record.readInt());
779}

781void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
VisitCastExpr(E);
E->setTypeInfoAsWritten(GetTypeSourceInfo());
784}

786void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
VisitExplicitCastExpr(E);
E->setLParenLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
790}

792void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
VisitExpr(E);
E->setLParenLoc(ReadSourceLocation());
E->setTypeSourceInfo(GetTypeSourceInfo());
E->setInitializer(Record.readSubExpr());
E->setFileScope(Record.readInt());
798}

800void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
VisitExpr(E);
E->setBase(Record.readSubExpr());
E->setAccessor(Record.getIdentifierInfo());
E->setAccessorLoc(ReadSourceLocation());
805}

807void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
VisitExpr(E);
if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
  E->setSyntacticForm(SyntForm);
E->setLBraceLoc(ReadSourceLocation());
E->setRBraceLoc(ReadSourceLocation());
bool isArrayFiller = Record.readInt();
Expr *filler = nullptr;
if (isArrayFiller) {
  filler = Record.readSubExpr();
  E->ArrayFillerOrUnionFieldInit = filler;
} else
  E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>();
E->sawArrayRangeDesignator(Record.readInt());
unsigned NumInits = Record.readInt();
E->reserveInits(Record.getContext(), NumInits);
if (isArrayFiller) {
  for (unsigned I = 0; I != NumInits; ++I) {
    Expr *init = Record.readSubExpr();
    E->updateInit(Record.getContext(), I, init ? init : filler);
  }
} else {
  for (unsigned I = 0; I != NumInits; ++I)
    E->updateInit(Record.getContext(), I, Record.readSubExpr());
}
832}

834void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
using Designator = DesignatedInitExpr::Designator;

VisitExpr(E);
unsigned NumSubExprs = Record.readInt();
assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs")((NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs"
) ? static_cast<void> (0) : __assert_fail ("NumSubExprs == E->getNumSubExprs() && \"Wrong number of subexprs\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 839, __PRETTY_FUNCTION__));
for (unsigned I = 0; I != NumSubExprs; ++I)
  E->setSubExpr(I, Record.readSubExpr());
E->setEqualOrColonLoc(ReadSourceLocation());
E->setGNUSyntax(Record.readInt());

SmallVector<Designator, 4> Designators;
while (Record.getIdx() < Record.size()) {
  switch ((DesignatorTypes)Record.readInt()) {
  case DESIG_FIELD_DECL: {
    auto *Field = ReadDeclAs<FieldDecl>();
    SourceLocation DotLoc = ReadSourceLocation();
    SourceLocation FieldLoc = ReadSourceLocation();
    Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
                                     FieldLoc));
    Designators.back().setField(Field);
    break;
  }

  case DESIG_FIELD_NAME: {
    const IdentifierInfo *Name = Record.getIdentifierInfo();
    SourceLocation DotLoc = ReadSourceLocation();
    SourceLocation FieldLoc = ReadSourceLocation();
    Designators.push_back(Designator(Name, DotLoc, FieldLoc));
    break;
  }

  case DESIG_ARRAY: {
    unsigned Index = Record.readInt();
    SourceLocation LBracketLoc = ReadSourceLocation();
    SourceLocation RBracketLoc = ReadSourceLocation();
    Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
    break;
  }

  case DESIG_ARRAY_RANGE: {
    unsigned Index = Record.readInt();
    SourceLocation LBracketLoc = ReadSourceLocation();
    SourceLocation EllipsisLoc = ReadSourceLocation();
    SourceLocation RBracketLoc = ReadSourceLocation();
    Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
                                     RBracketLoc));
    break;
  }
  }
}
E->setDesignators(Record.getContext(),
                  Designators.data(), Designators.size());
887}

889void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
VisitExpr(E);
E->setBase(Record.readSubExpr());
E->setUpdater(Record.readSubExpr());
893}

895void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
VisitExpr(E);
897}

899void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
VisitExpr(E);
E->SubExprs[0] = Record.readSubExpr();
E->SubExprs[1] = Record.readSubExpr();
903}

905void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
VisitExpr(E);
907}

909void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
VisitExpr(E);
911}

913void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
VisitExpr(E);
E->setSubExpr(Record.readSubExpr());
E->setWrittenTypeInfo(GetTypeSourceInfo());
E->setBuiltinLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
E->setIsMicrosoftABI(Record.readInt());
920}

922void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
VisitExpr(E);
E->setAmpAmpLoc(ReadSourceLocation());
E->setLabelLoc(ReadSourceLocation());
E->setLabel(ReadDeclAs<LabelDecl>());
927}

929void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
VisitExpr(E);
E->setLParenLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
934}

936void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
VisitExpr(E);
E->setCond(Record.readSubExpr());
E->setLHS(Record.readSubExpr());
E->setRHS(Record.readSubExpr());
E->setBuiltinLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
E->setIsConditionTrue(Record.readInt());
944}

946void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
VisitExpr(E);
E->setTokenLocation(ReadSourceLocation());
949}

951void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
VisitExpr(E);
SmallVector<Expr *, 16> Exprs;
unsigned NumExprs = Record.readInt();
while (NumExprs--)
  Exprs.push_back(Record.readSubExpr());
E->setExprs(Record.getContext(), Exprs);
E->setBuiltinLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
960}

962void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
VisitExpr(E);
E->BuiltinLoc = ReadSourceLocation();
E->RParenLoc = ReadSourceLocation();
E->TInfo = GetTypeSourceInfo();
E->SrcExpr = Record.readSubExpr();
968}

970void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
VisitExpr(E);
E->setBlockDecl(ReadDeclAs<BlockDecl>());
973}

975void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
VisitExpr(E);
E->NumAssocs = Record.readInt();
E->AssocTypes = new (Record.getContext()) TypeSourceInfo*[E->NumAssocs];
E->SubExprs =
 new(Record.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];

E->SubExprs[GenericSelectionExpr::CONTROLLING] = Record.readSubExpr();
for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
  E->AssocTypes[I] = GetTypeSourceInfo();
  E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Record.readSubExpr();
}
E->ResultIndex = Record.readInt();

E->GenericLoc = ReadSourceLocation();
E->DefaultLoc = ReadSourceLocation();
E->RParenLoc = ReadSourceLocation();
992}

994void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
VisitExpr(E);
unsigned numSemanticExprs = Record.readInt();
assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs)((numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs
) ? static_cast<void> (0) : __assert_fail ("numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 997, __PRETTY_FUNCTION__));
E->PseudoObjectExprBits.ResultIndex = Record.readInt();

// Read the syntactic expression.
E->getSubExprsBuffer()[0] = Record.readSubExpr();

// Read all the semantic expressions.
for (unsigned i = 0; i != numSemanticExprs; ++i) {
  Expr *subExpr = Record.readSubExpr();
  E->getSubExprsBuffer()[i+1] = subExpr;
}
1008}

1010void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
VisitExpr(E);
E->Op = AtomicExpr::AtomicOp(Record.readInt());
E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
for (unsigned I = 0; I != E->NumSubExprs; ++I)
  E->SubExprs[I] = Record.readSubExpr();
E->BuiltinLoc = ReadSourceLocation();
E->RParenLoc = ReadSourceLocation();
1018}

1020//===----------------------------------------------------------------------===//
1021// Objective-C Expressions and Statements

1023void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
VisitExpr(E);
E->setString(cast<StringLiteral>(Record.readSubStmt()));
E->setAtLoc(ReadSourceLocation());
1027}

1029void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
VisitExpr(E);
// could be one of several IntegerLiteral, FloatLiteral, etc.
E->SubExpr = Record.readSubStmt();
E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>();
E->Range = ReadSourceRange();
1035}

1037void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
VisitExpr(E);
unsigned NumElements = Record.readInt();
assert(NumElements == E->getNumElements() && "Wrong number of elements")((NumElements == E->getNumElements() && "Wrong number of elements"
) ? static_cast<void> (0) : __assert_fail ("NumElements == E->getNumElements() && \"Wrong number of elements\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1040, __PRETTY_FUNCTION__));
Expr **Elements = E->getElements();
for (unsigned I = 0, N = NumElements; I != N; ++I)
  Elements[I] = Record.readSubExpr();
E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
E->Range = ReadSourceRange();
1046}

1048void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
VisitExpr(E);
unsigned NumElements = Record.readInt();
assert(NumElements == E->getNumElements() && "Wrong number of elements")((NumElements == E->getNumElements() && "Wrong number of elements"
) ? static_cast<void> (0) : __assert_fail ("NumElements == E->getNumElements() && \"Wrong number of elements\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1051, __PRETTY_FUNCTION__));
bool HasPackExpansions = Record.readInt();
assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch")((HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch"
) ? static_cast<void> (0) : __assert_fail ("HasPackExpansions == E->HasPackExpansions &&\"Pack expansion mismatch\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1053, __PRETTY_FUNCTION__));
auto *KeyValues =
    E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
auto *Expansions =
    E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
for (unsigned I = 0; I != NumElements; ++I) {
  KeyValues[I].Key = Record.readSubExpr();
  KeyValues[I].Value = Record.readSubExpr();
  if (HasPackExpansions) {
    Expansions[I].EllipsisLoc = ReadSourceLocation();
    Expansions[I].NumExpansionsPlusOne = Record.readInt();
  }
}
E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
E->Range = ReadSourceRange();
1068}

1070void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
VisitExpr(E);
E->setEncodedTypeSourceInfo(GetTypeSourceInfo());
E->setAtLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
1075}

1077void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
VisitExpr(E);
E->setSelector(Record.readSelector());
E->setAtLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
1082}

1084void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
VisitExpr(E);
E->setProtocol(ReadDeclAs<ObjCProtocolDecl>());
E->setAtLoc(ReadSourceLocation());
E->ProtoLoc = ReadSourceLocation();
E->setRParenLoc(ReadSourceLocation());
1090}

1092void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
VisitExpr(E);
E->setDecl(ReadDeclAs<ObjCIvarDecl>());
E->setLocation(ReadSourceLocation());
E->setOpLoc(ReadSourceLocation());
E->setBase(Record.readSubExpr());
E->setIsArrow(Record.readInt());
E->setIsFreeIvar(Record.readInt());
1100}

1102void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
VisitExpr(E);
unsigned MethodRefFlags = Record.readInt();
bool Implicit = Record.readInt() != 0;
if (Implicit) {
  auto *Getter = ReadDeclAs<ObjCMethodDecl>();
  auto *Setter = ReadDeclAs<ObjCMethodDecl>();
  E->setImplicitProperty(Getter, Setter, MethodRefFlags);
} else {
  E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
}
E->setLocation(ReadSourceLocation());
E->setReceiverLocation(ReadSourceLocation());
switch (Record.readInt()) {
case 0:
  E->setBase(Record.readSubExpr());
  break;
case 1:
  E->setSuperReceiver(Record.readType());
  break;
case 2:
  E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>());
  break;
}
1126}

1128void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
VisitExpr(E);
E->setRBracket(ReadSourceLocation());
E->setBaseExpr(Record.readSubExpr());
E->setKeyExpr(Record.readSubExpr());
E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
1135}

1137void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
VisitExpr(E);
assert(Record.peekInt() == E->getNumArgs())((Record.peekInt() == E->getNumArgs()) ? static_cast<void
> (0) : __assert_fail ("Record.peekInt() == E->getNumArgs()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1139, __PRETTY_FUNCTION__));
Record.skipInts(1);
unsigned NumStoredSelLocs = Record.readInt();
E->SelLocsKind = Record.readInt();
E->setDelegateInitCall(Record.readInt());
E->IsImplicit = Record.readInt();
auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
switch (Kind) {
case ObjCMessageExpr::Instance:
  E->setInstanceReceiver(Record.readSubExpr());
  break;

case ObjCMessageExpr::Class:
  E->setClassReceiver(GetTypeSourceInfo());
  break;

case ObjCMessageExpr::SuperClass:
case ObjCMessageExpr::SuperInstance: {
  QualType T = Record.readType();
  SourceLocation SuperLoc = ReadSourceLocation();
  E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
  break;
}
}

assert(Kind == E->getReceiverKind())((Kind == E->getReceiverKind()) ? static_cast<void> (
0) : __assert_fail ("Kind == E->getReceiverKind()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1164, __PRETTY_FUNCTION__));

if (Record.readInt())
  E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>());
else
  E->setSelector(Record.readSelector());

E->LBracLoc = ReadSourceLocation();
E->RBracLoc = ReadSourceLocation();

for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
  E->setArg(I, Record.readSubExpr());

SourceLocation *Locs = E->getStoredSelLocs();
for (unsigned I = 0; I != NumStoredSelLocs; ++I)
  Locs[I] = ReadSourceLocation();
1180}

1182void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
VisitStmt(S);
S->setElement(Record.readSubStmt());
S->setCollection(Record.readSubExpr());
S->setBody(Record.readSubStmt());
S->setForLoc(ReadSourceLocation());
S->setRParenLoc(ReadSourceLocation());
1189}

1191void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
VisitStmt(S);
S->setCatchBody(Record.readSubStmt());
S->setCatchParamDecl(ReadDeclAs<VarDecl>());
S->setAtCatchLoc(ReadSourceLocation());
S->setRParenLoc(ReadSourceLocation());
1197}

1199void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
VisitStmt(S);
S->setFinallyBody(Record.readSubStmt());
S->setAtFinallyLoc(ReadSourceLocation());
1203}

1205void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
VisitStmt(S);
S->setSubStmt(Record.readSubStmt());
S->setAtLoc(ReadSourceLocation());
1209}

1211void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
VisitStmt(S);
assert(Record.peekInt() == S->getNumCatchStmts())((Record.peekInt() == S->getNumCatchStmts()) ? static_cast
<void> (0) : __assert_fail ("Record.peekInt() == S->getNumCatchStmts()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1213, __PRETTY_FUNCTION__));
Record.skipInts(1);
bool HasFinally = Record.readInt();
S->setTryBody(Record.readSubStmt());
for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
  S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt()));

if (HasFinally)
  S->setFinallyStmt(Record.readSubStmt());
S->setAtTryLoc(ReadSourceLocation());
1223}

1225void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
VisitStmt(S);
S->setSynchExpr(Record.readSubStmt());
S->setSynchBody(Record.readSubStmt());
S->setAtSynchronizedLoc(ReadSourceLocation());
1230}

1232void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
VisitStmt(S);
S->setThrowExpr(Record.readSubStmt());
S->setThrowLoc(ReadSourceLocation());
1236}

1238void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
VisitExpr(E);
E->setValue(Record.readInt());
E->setLocation(ReadSourceLocation());
1242}

1244void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
VisitExpr(E);
SourceRange R = Record.readSourceRange();
E->AtLoc = R.getBegin();
E->RParen = R.getEnd();
E->VersionToCheck = Record.readVersionTuple();
1250}

1252//===----------------------------------------------------------------------===//
1253// C++ Expressions and Statements
1254//===----------------------------------------------------------------------===//

1256void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
VisitStmt(S);
S->CatchLoc = ReadSourceLocation();
S->ExceptionDecl = ReadDeclAs<VarDecl>();
S->HandlerBlock = Record.readSubStmt();
1261}

1263void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
VisitStmt(S);
assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?")((Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?"
) ? static_cast<void> (0) : __assert_fail ("Record.peekInt() == S->getNumHandlers() && \"NumStmtFields is wrong ?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1265, __PRETTY_FUNCTION__));
Record.skipInts(1);
S->TryLoc = ReadSourceLocation();
S->getStmts()[0] = Record.readSubStmt();
for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
  S->getStmts()[i + 1] = Record.readSubStmt();
1271}

1273void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
VisitStmt(S);
S->ForLoc = ReadSourceLocation();
S->CoawaitLoc = ReadSourceLocation();
S->ColonLoc = ReadSourceLocation();
S->RParenLoc = ReadSourceLocation();
S->setInit(Record.readSubStmt());
S->setRangeStmt(Record.readSubStmt());
S->setBeginStmt(Record.readSubStmt());
S->setEndStmt(Record.readSubStmt());
S->setCond(Record.readSubExpr());
S->setInc(Record.readSubExpr());
S->setLoopVarStmt(Record.readSubStmt());
S->setBody(Record.readSubStmt());
1287}

1289void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
VisitStmt(S);
S->KeywordLoc = ReadSourceLocation();
S->IsIfExists = Record.readInt();
S->QualifierLoc = Record.readNestedNameSpecifierLoc();
ReadDeclarationNameInfo(S->NameInfo);
S->SubStmt = Record.readSubStmt();
1296}

1298void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
VisitCallExpr(E);
E->Operator = (OverloadedOperatorKind)Record.readInt();
E->Range = Record.readSourceRange();
E->setFPFeatures(FPOptions(Record.readInt()));
1303}

1305void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
VisitExpr(E);
E->NumArgs = Record.readInt();
if (E->NumArgs)
  E->Args = new (Record.getContext()) Stmt*[E->NumArgs];
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
  E->setArg(I, Record.readSubExpr());
E->setConstructor(ReadDeclAs<CXXConstructorDecl>());
E->setLocation(ReadSourceLocation());
E->setElidable(Record.readInt());
E->setHadMultipleCandidates(Record.readInt());
E->setListInitialization(Record.readInt());
E->setStdInitListInitialization(Record.readInt());
E->setRequiresZeroInitialization(Record.readInt());
E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record.readInt());
E->ParenOrBraceRange = ReadSourceRange();
1321}

1323void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
VisitExpr(E);
E->Constructor = ReadDeclAs<CXXConstructorDecl>();
E->Loc = ReadSourceLocation();
E->ConstructsVirtualBase = Record.readInt();
E->InheritedFromVirtualBase = Record.readInt();
1329}

1331void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
VisitCXXConstructExpr(E);
E->Type = GetTypeSourceInfo();
1334}

1336void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
VisitExpr(E);
unsigned NumCaptures = Record.readInt();
assert(NumCaptures == E->NumCaptures)((NumCaptures == E->NumCaptures) ? static_cast<void>
 (0) : __assert_fail ("NumCaptures == E->NumCaptures", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1339, __PRETTY_FUNCTION__));(void)NumCaptures;
E->IntroducerRange = ReadSourceRange();
E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record.readInt());
E->CaptureDefaultLoc = ReadSourceLocation();
E->ExplicitParams = Record.readInt();
E->ExplicitResultType = Record.readInt();
E->ClosingBrace = ReadSourceLocation();

// Read capture initializers.
for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
                                    CEnd = E->capture_init_end();
     C != CEnd; ++C)
  *C = Record.readSubExpr();
1352}

1354void
1355ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
VisitExpr(E);
E->SubExpr = Record.readSubExpr();
1358}

1360void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
VisitExplicitCastExpr(E);
SourceRange R = ReadSourceRange();
E->Loc = R.getBegin();
E->RParenLoc = R.getEnd();
R = ReadSourceRange();
E->AngleBrackets = R;
1367}

1369void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
return VisitCXXNamedCastExpr(E);
1371}

1373void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
return VisitCXXNamedCastExpr(E);
1375}

1377void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
return VisitCXXNamedCastExpr(E);
1379}

1381void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
return VisitCXXNamedCastExpr(E);
1383}

1385void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
VisitExplicitCastExpr(E);
E->setLParenLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
1389}

1391void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
VisitCallExpr(E);
E->UDSuffixLoc = ReadSourceLocation();
1394}

1396void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
VisitExpr(E);
E->setValue(Record.readInt());
E->setLocation(ReadSourceLocation());
1400}

1402void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
VisitExpr(E);
E->setLocation(ReadSourceLocation());
1405}

1407void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
VisitExpr(E);
E->setSourceRange(ReadSourceRange());
if (E->isTypeOperand()) { // typeid(int)
  E->setTypeOperandSourceInfo(
      GetTypeSourceInfo());
  return;
}

// typeid(42+2)
E->setExprOperand(Record.readSubExpr());
1418}

1420void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
VisitExpr(E);
E->setLocation(ReadSourceLocation());
E->setImplicit(Record.readInt());
1424}

1426void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
VisitExpr(E);
E->ThrowLoc = ReadSourceLocation();
E->Op = Record.readSubExpr();
E->IsThrownVariableInScope = Record.readInt();
1431}

1433void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
VisitExpr(E);
E->Param = ReadDeclAs<ParmVarDecl>();
E->Loc = ReadSourceLocation();
1437}

1439void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
VisitExpr(E);
E->Field = ReadDeclAs<FieldDecl>();
E->Loc = ReadSourceLocation();
1443}

1445void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
VisitExpr(E);
E->setTemporary(Record.readCXXTemporary());
E->setSubExpr(Record.readSubExpr());
1449}

1451void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
VisitExpr(E);
E->TypeInfo = GetTypeSourceInfo();
E->RParenLoc = ReadSourceLocation();
1455}

1457void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
VisitExpr(E);
E->GlobalNew = Record.readInt();
bool isArray = Record.readInt();
E->PassAlignment = Record.readInt();
E->UsualArrayDeleteWantsSize = Record.readInt();
unsigned NumPlacementArgs = Record.readInt();
E->StoredInitializationStyle = Record.readInt();
E->setOperatorNew(ReadDeclAs<FunctionDecl>());
E->setOperatorDelete(ReadDeclAs<FunctionDecl>());
E->AllocatedTypeInfo = GetTypeSourceInfo();
E->TypeIdParens = ReadSourceRange();
E->Range = ReadSourceRange();
E->DirectInitRange = ReadSourceRange();

E->AllocateArgsArray(Record.getContext(), isArray, NumPlacementArgs,
                     E->StoredInitializationStyle != 0);

// Install all the subexpressions.
for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
     I != e; ++I)
  *I = Record.readSubStmt();
1479}

1481void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
VisitExpr(E);
E->GlobalDelete = Record.readInt();
E->ArrayForm = Record.readInt();
E->ArrayFormAsWritten = Record.readInt();
E->UsualArrayDeleteWantsSize = Record.readInt();
E->OperatorDelete = ReadDeclAs<FunctionDecl>();
E->Argument = Record.readSubExpr();
E->Loc = ReadSourceLocation();
1490}

1492void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
VisitExpr(E);

E->Base = Record.readSubExpr();
E->IsArrow = Record.readInt();
E->OperatorLoc = ReadSourceLocation();
E->QualifierLoc = Record.readNestedNameSpecifierLoc();
E->ScopeType = GetTypeSourceInfo();
E->ColonColonLoc = ReadSourceLocation();
E->TildeLoc = ReadSourceLocation();

IdentifierInfo *II = Record.getIdentifierInfo();
if (II)
  E->setDestroyedType(II, ReadSourceLocation());
else
  E->setDestroyedType(GetTypeSourceInfo());
1508}

1510void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
VisitExpr(E);

unsigned NumObjects = Record.readInt();
assert(NumObjects == E->getNumObjects())((NumObjects == E->getNumObjects()) ? static_cast<void>
 (0) : __assert_fail ("NumObjects == E->getNumObjects()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1514, __PRETTY_FUNCTION__));
for (unsigned i = 0; i != NumObjects; ++i)
  E->getTrailingObjects<BlockDecl *>()[i] =
      ReadDeclAs<BlockDecl>();

E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
E->SubExpr = Record.readSubExpr();
1521}

1523void
1524ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
VisitExpr(E);

if (Record.readInt()) // HasTemplateKWAndArgsInfo
  ReadTemplateKWAndArgsInfo(
      *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
      E->getTrailingObjects<TemplateArgumentLoc>(),
      /*NumTemplateArgs=*/Record.readInt());

E->Base = Record.readSubExpr();
E->BaseType = Record.readType();
E->IsArrow = Record.readInt();
E->OperatorLoc = ReadSourceLocation();
E->QualifierLoc = Record.readNestedNameSpecifierLoc();
E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>();
ReadDeclarationNameInfo(E->MemberNameInfo);
1540}

1542void
1543ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
VisitExpr(E);

if (Record.readInt()) // HasTemplateKWAndArgsInfo
  ReadTemplateKWAndArgsInfo(
      *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
      E->getTrailingObjects<TemplateArgumentLoc>(),
      /*NumTemplateArgs=*/Record.readInt());

E->QualifierLoc = Record.readNestedNameSpecifierLoc();
ReadDeclarationNameInfo(E->NameInfo);
1554}

1556void
1557ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
VisitExpr(E);
assert(Record.peekInt() == E->arg_size() &&((Record.peekInt() == E->arg_size() && "Read wrong record during creation ?"
) ? static_cast<void> (0) : __assert_fail ("Record.peekInt() == E->arg_size() && \"Read wrong record during creation ?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1560, __PRETTY_FUNCTION__))
       "Read wrong record during creation ?")((Record.peekInt() == E->arg_size() && "Read wrong record during creation ?"
) ? static_cast<void> (0) : __assert_fail ("Record.peekInt() == E->arg_size() && \"Read wrong record during creation ?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1560, __PRETTY_FUNCTION__));
Record.skipInts(1);
for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
  E->setArg(I, Record.readSubExpr());
E->Type = GetTypeSourceInfo();
E->setLParenLoc(ReadSourceLocation());
E->setRParenLoc(ReadSourceLocation());
1567}

1569void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
VisitExpr(E);

if (Record.readInt()) // HasTemplateKWAndArgsInfo
  ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
                            E->getTrailingTemplateArgumentLoc(),
                            /*NumTemplateArgs=*/Record.readInt());

unsigned NumDecls = Record.readInt();
UnresolvedSet<8> Decls;
for (unsigned i = 0; i != NumDecls; ++i) {
  auto *D = ReadDeclAs<NamedDecl>();
  auto AS = (AccessSpecifier)Record.readInt();
  Decls.addDecl(D, AS);
}
E->initializeResults(Record.getContext(), Decls.begin(), Decls.end());

ReadDeclarationNameInfo(E->NameInfo);
E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1588}

1590void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
VisitOverloadExpr(E);
E->IsArrow = Record.readInt();
E->HasUnresolvedUsing = Record.readInt();
E->Base = Record.readSubExpr();
E->BaseType = Record.readType();
E->OperatorLoc = ReadSourceLocation();
1597}

1599void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
VisitOverloadExpr(E);
E->RequiresADL = Record.readInt();
E->Overloaded = Record.readInt();
E->NamingClass = ReadDeclAs<CXXRecordDecl>();
1604}

1606void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
VisitExpr(E);
E->TypeTraitExprBits.NumArgs = Record.readInt();
E->TypeTraitExprBits.Kind = Record.readInt();
E->TypeTraitExprBits.Value = Record.readInt();
SourceRange Range = ReadSourceRange();
E->Loc = Range.getBegin();
E->RParenLoc = Range.getEnd();

auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
  Args[I] = GetTypeSourceInfo();
1618}

1620void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
VisitExpr(E);
E->ATT = (ArrayTypeTrait)Record.readInt();
E->Value = (unsigned int)Record.readInt();
SourceRange Range = ReadSourceRange();
E->Loc = Range.getBegin();
E->RParen = Range.getEnd();
E->QueriedType = GetTypeSourceInfo();
E->Dimension = Record.readSubExpr();
1629}

1631void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
VisitExpr(E);
E->ET = (ExpressionTrait)Record.readInt();
E->Value = (bool)Record.readInt();
SourceRange Range = ReadSourceRange();
E->QueriedExpression = Record.readSubExpr();
E->Loc = Range.getBegin();
E->RParen = Range.getEnd();
1639}

1641void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
VisitExpr(E);
E->Value = (bool)Record.readInt();
E->Range = ReadSourceRange();
E->Operand = Record.readSubExpr();
1646}

1648void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
VisitExpr(E);
E->EllipsisLoc = ReadSourceLocation();
E->NumExpansions = Record.readInt();
E->Pattern = Record.readSubExpr();
1653}

1655void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
VisitExpr(E);
unsigned NumPartialArgs = Record.readInt();
E->OperatorLoc = ReadSourceLocation();
E->PackLoc = ReadSourceLocation();
E->RParenLoc = ReadSourceLocation();
E->Pack = Record.readDeclAs<NamedDecl>();
if (E->isPartiallySubstituted()) {
  assert(E->Length == NumPartialArgs)((E->Length == NumPartialArgs) ? static_cast<void> (
0) : __assert_fail ("E->Length == NumPartialArgs", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1663, __PRETTY_FUNCTION__));
  for (auto *I = E->getTrailingObjects<TemplateArgument>(),
            *E = I + NumPartialArgs;
       I != E; ++I)
    new (I) TemplateArgument(Record.readTemplateArgument());
} else if (!E->isValueDependent()) {
  E->Length = Record.readInt();
}
1671}

1673void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
                                            SubstNonTypeTemplateParmExpr *E) {
VisitExpr(E);
E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
E->NameLoc = ReadSourceLocation();
E->Replacement = Record.readSubExpr();
1679}

1681void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
                                        SubstNonTypeTemplateParmPackExpr *E) {
VisitExpr(E);
E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
TemplateArgument ArgPack = Record.readTemplateArgument();
if (ArgPack.getKind() != TemplateArgument::Pack)
  return;

E->Arguments = ArgPack.pack_begin();
E->NumArguments = ArgPack.pack_size();
E->NameLoc = ReadSourceLocation();
1692}

1694void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
VisitExpr(E);
E->NumParameters = Record.readInt();
E->ParamPack = ReadDeclAs<ParmVarDecl>();
E->NameLoc = ReadSourceLocation();
auto **Parms = E->getTrailingObjects<ParmVarDecl *>();
for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
  Parms[i] = ReadDeclAs<ParmVarDecl>();
1702}

1704void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
VisitExpr(E);
E->State = Record.readSubExpr();
auto *VD = ReadDeclAs<ValueDecl>();
unsigned ManglingNumber = Record.readInt();
E->setExtendingDecl(VD, ManglingNumber);
1710}

1712void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
VisitExpr(E);
E->LParenLoc = ReadSourceLocation();
E->EllipsisLoc = ReadSourceLocation();
E->RParenLoc = ReadSourceLocation();
E->SubExprs[0] = Record.readSubExpr();
E->SubExprs[1] = Record.readSubExpr();
E->Opcode = (BinaryOperatorKind)Record.readInt();
1720}

1722void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
VisitExpr(E);
E->SourceExpr = Record.readSubExpr();
E->Loc = ReadSourceLocation();
E->setIsUnique(Record.readInt());
1727}

1729void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
llvm_unreachable("Cannot read TypoExpr nodes")::llvm::llvm_unreachable_internal("Cannot read TypoExpr nodes"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1730);
1731}

1733//===----------------------------------------------------------------------===//
1734// Microsoft Expressions and Statements
1735//===----------------------------------------------------------------------===//
1736void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
VisitExpr(E);
E->IsArrow = (Record.readInt() != 0);
E->BaseExpr = Record.readSubExpr();
E->QualifierLoc = Record.readNestedNameSpecifierLoc();
E->MemberLoc = ReadSourceLocation();
E->TheDecl = ReadDeclAs<MSPropertyDecl>();
1743}

1745void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
VisitExpr(E);
E->setBase(Record.readSubExpr());
E->setIdx(Record.readSubExpr());
E->setRBracketLoc(ReadSourceLocation());
1750}

1752void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
VisitExpr(E);
E->setSourceRange(ReadSourceRange());
std::string UuidStr = ReadString();
E->setUuidStr(StringRef(UuidStr).copy(Record.getContext()));
if (E->isTypeOperand()) { // __uuidof(ComType)
  E->setTypeOperandSourceInfo(
      GetTypeSourceInfo());
  return;
}

// __uuidof(expr)
E->setExprOperand(Record.readSubExpr());
1765}

1767void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
VisitStmt(S);
S->setLeaveLoc(ReadSourceLocation());
1770}

1772void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
VisitStmt(S);
S->Loc = ReadSourceLocation();
S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
1777}

1779void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
VisitStmt(S);
S->Loc = ReadSourceLocation();
S->Block = Record.readSubStmt();
1783}

1785void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
VisitStmt(S);
S->IsCXXTry = Record.readInt();
S->TryLoc = ReadSourceLocation();
S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
1791}

1793//===----------------------------------------------------------------------===//
1794// CUDA Expressions and Statements
1795//===----------------------------------------------------------------------===//

1797void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
VisitCallExpr(E);
E->setConfig(cast<CallExpr>(Record.readSubExpr()));
1800}

1802//===----------------------------------------------------------------------===//
1803// OpenCL Expressions and Statements.
1804//===----------------------------------------------------------------------===//
1805void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
VisitExpr(E);
E->BuiltinLoc = ReadSourceLocation();
E->RParenLoc = ReadSourceLocation();
E->SrcExpr = Record.readSubExpr();
1810}

1812//===----------------------------------------------------------------------===//
1813// OpenMP Directives.
1814//===----------------------------------------------------------------------===//

1816void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
E->setLocStart(ReadSourceLocation());
E->setLocEnd(ReadSourceLocation());
OMPClauseReader ClauseReader(Record);
SmallVector<OMPClause *, 5> Clauses;
for (unsigned i = 0; i < E->getNumClauses(); ++i)
  Clauses.push_back(ClauseReader.readClause());
E->setClauses(Clauses);
if (E->hasAssociatedStmt())
  E->setAssociatedStmt(Record.readSubStmt());
1826}

1828void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
VisitStmt(D);
// Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
Record.skipInts(2);
VisitOMPExecutableDirective(D);
D->setIterationVariable(Record.readSubExpr());
D->setLastIteration(Record.readSubExpr());
D->setCalcLastIteration(Record.readSubExpr());
D->setPreCond(Record.readSubExpr());
D->setCond(Record.readSubExpr());
D->setInit(Record.readSubExpr());
D->setInc(Record.readSubExpr());
D->setPreInits(Record.readSubStmt());
if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
    isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
    isOpenMPDistributeDirective(D->getDirectiveKind())) {
  D->setIsLastIterVariable(Record.readSubExpr());
  D->setLowerBoundVariable(Record.readSubExpr());
  D->setUpperBoundVariable(Record.readSubExpr());
  D->setStrideVariable(Record.readSubExpr());
  D->setEnsureUpperBound(Record.readSubExpr());
  D->setNextLowerBound(Record.readSubExpr());
  D->setNextUpperBound(Record.readSubExpr());
  D->setNumIterations(Record.readSubExpr());
}
if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
  D->setPrevLowerBoundVariable(Record.readSubExpr());
  D->setPrevUpperBoundVariable(Record.readSubExpr());
  D->setDistInc(Record.readSubExpr());
  D->setPrevEnsureUpperBound(Record.readSubExpr());
  D->setCombinedLowerBoundVariable(Record.readSubExpr());
  D->setCombinedUpperBoundVariable(Record.readSubExpr());
  D->setCombinedEnsureUpperBound(Record.readSubExpr());
  D->setCombinedInit(Record.readSubExpr());
  D->setCombinedCond(Record.readSubExpr());
  D->setCombinedNextLowerBound(Record.readSubExpr());
  D->setCombinedNextUpperBound(Record.readSubExpr());
}
SmallVector<Expr *, 4> Sub;
unsigned CollapsedNum = D->getCollapsedNumber();
Sub.reserve(CollapsedNum);
for (unsigned i = 0; i < CollapsedNum; ++i)
  Sub.push_back(Record.readSubExpr());
D->setCounters(Sub);
Sub.clear();
for (unsigned i = 0; i < CollapsedNum; ++i)
  Sub.push_back(Record.readSubExpr());
D->setPrivateCounters(Sub);
Sub.clear();
for (unsigned i = 0; i < CollapsedNum; ++i)
  Sub.push_back(Record.readSubExpr());
D->setInits(Sub);
Sub.clear();
for (unsigned i = 0; i < CollapsedNum; ++i)
  Sub.push_back(Record.readSubExpr());
D->setUpdates(Sub);
Sub.clear();
for (unsigned i = 0; i < CollapsedNum; ++i)
  Sub.push_back(Record.readSubExpr());
D->setFinals(Sub);
1888}

1890void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
D->setHasCancel(Record.readInt());
1896}

1898void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
VisitOMPLoopDirective(D);
1900}

1902void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
VisitOMPLoopDirective(D);
D->setHasCancel(Record.readInt());
1905}

1907void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
VisitOMPLoopDirective(D);
1909}

1911void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
D->setHasCancel(Record.readInt());
1917}

1919void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
D->setHasCancel(Record.readInt());
1923}

1925void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
1930}

1932void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
1935}

1937void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
ReadDeclarationNameInfo(D->DirName);
1943}

1945void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
VisitOMPLoopDirective(D);
D->setHasCancel(Record.readInt());
1948}

1950void ASTStmtReader::VisitOMPParallelForSimdDirective(
  OMPParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
1953}

1955void ASTStmtReader::VisitOMPParallelSectionsDirective(
  OMPParallelSectionsDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
D->setHasCancel(Record.readInt());
1962}

1964void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
D->setHasCancel(Record.readInt());
1970}

1972void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
1975}

1977void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
1980}

1982void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
1985}

1987void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
D->setReductionRef(Record.readSubExpr());
1993}

1995void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2000}

2002void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2007}

2009void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
D->setX(Record.readSubExpr());
D->setV(Record.readSubExpr());
D->setExpr(Record.readSubExpr());
D->setUpdateExpr(Record.readSubExpr());
D->IsXLHSInRHSPart = Record.readInt() != 0;
D->IsPostfixUpdate = Record.readInt() != 0;
2020}

2022void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2027}

2029void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
VisitStmt(D);
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2033}

2035void ASTStmtReader::VisitOMPTargetEnterDataDirective(
  OMPTargetEnterDataDirective *D) {
VisitStmt(D);
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2040}

2042void ASTStmtReader::VisitOMPTargetExitDataDirective(
  OMPTargetExitDataDirective *D) {
VisitStmt(D);
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2047}

2049void ASTStmtReader::VisitOMPTargetParallelDirective(
  OMPTargetParallelDirective *D) {
VisitStmt(D);
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2054}

2056void ASTStmtReader::VisitOMPTargetParallelForDirective(
  OMPTargetParallelForDirective *D) {
VisitOMPLoopDirective(D);
D->setHasCancel(Record.readInt());
2060}

2062void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2067}

2069void ASTStmtReader::VisitOMPCancellationPointDirective(
  OMPCancellationPointDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2074}

2076void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2082}

2084void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
2086}

2088void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
2090}

2092void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
VisitOMPLoopDirective(D);
2094}

2096void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
VisitStmt(D);
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2100}

2102void ASTStmtReader::VisitOMPDistributeParallelForDirective(
  OMPDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
D->setHasCancel(Record.readInt());
2106}

2108void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
  OMPDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
2111}

2113void ASTStmtReader::VisitOMPDistributeSimdDirective(
  OMPDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
2116}

2118void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
  OMPTargetParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
2121}

2123void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
VisitOMPLoopDirective(D);
2125}

2127void ASTStmtReader::VisitOMPTeamsDistributeDirective(
  OMPTeamsDistributeDirective *D) {
VisitOMPLoopDirective(D);
2130}

2132void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
  OMPTeamsDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
2135}

2137void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
  OMPTeamsDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
2140}

2142void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
  OMPTeamsDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
D->setHasCancel(Record.readInt());
2146}

2148void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
Record.skipInts(1);
VisitOMPExecutableDirective(D);
2153}

2155void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
  OMPTargetTeamsDistributeDirective *D) {
VisitOMPLoopDirective(D);
2158}

2160void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
  OMPTargetTeamsDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
D->setHasCancel(Record.readInt());
2164}

2166void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
  OMPTargetTeamsDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
2169}

2171void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
  OMPTargetTeamsDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
2174}

2176//===----------------------------------------------------------------------===//
2177// ASTReader Implementation
2178//===----------------------------------------------------------------------===//

2180Stmt *ASTReader::ReadStmt(ModuleFile &F) {
switch (ReadingKind) {
case Read_None:
  llvm_unreachable("should not call this when not reading anything")::llvm::llvm_unreachable_internal("should not call this when not reading anything"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2183);
case Read_Decl:
case Read_Type:
  return ReadStmtFromStream(F);
case Read_Stmt:
  return ReadSubStmt();
}

llvm_unreachable("ReadingKind not set ?")::llvm::llvm_unreachable_internal("ReadingKind not set ?", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2191);
2192}

2194Expr *ASTReader::ReadExpr(ModuleFile &F) {
return cast_or_null<Expr>(ReadStmt(F));
2196}

2198Expr *ASTReader::ReadSubExpr() {
return cast_or_null<Expr>(ReadSubStmt());
2200}

2202// Within the bitstream, expressions are stored in Reverse Polish
2203// Notation, with each of the subexpressions preceding the
2204// expression they are stored in. Subexpressions are stored from last to first.
2205// To evaluate expressions, we continue reading expressions and placing them on
2206// the stack, with expressions having operands removing those operands from the
2207// stack. Evaluation terminates when we see a STMT_STOP record, and
2208// the single remaining expression on the stack is our result.
2209Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
ReadingKindTracker ReadingKind(Read_Stmt, *this);
llvm::BitstreamCursor &Cursor = F.DeclsCursor;

// Map of offset to previously deserialized stmt. The offset points
// just after the stmt record.
llvm::DenseMap<uint64_t, Stmt *> StmtEntries;

2217#ifndef NDEBUG
unsigned PrevNumStmts = StmtStack.size();
2219#endif

ASTRecordReader Record(*this, F);
ASTStmtReader Reader(Record, Cursor);
Stmt::EmptyShell Empty;

while (true) {
  llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();

  switch (Entry.Kind) {
  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
  case llvm::BitstreamEntry::Error:
    Error("malformed block record in AST file");
    return nullptr;
  case llvm::BitstreamEntry::EndBlock:
    goto Done;
  case llvm::BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  ASTContext &Context = getContext();
  Stmt *S = nullptr;
  bool Finished = false;
  bool IsStmtReference = false;
  switch ((StmtCode)Record.readRecord(Cursor, Entry.ID)) {
  case STMT_STOP:
    Finished = true;
    break;

  case STMT_REF_PTR:
    IsStmtReference = true;
    assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&((StmtEntries.find(Record[0]) != StmtEntries.end() &&
 "No stmt was recorded for this offset reference!") ? static_cast
<void> (0) : __assert_fail ("StmtEntries.find(Record[0]) != StmtEntries.end() && \"No stmt was recorded for this offset reference!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2252, __PRETTY_FUNCTION__))
           "No stmt was recorded for this offset reference!")((StmtEntries.find(Record[0]) != StmtEntries.end() &&
 "No stmt was recorded for this offset reference!") ? static_cast
<void> (0) : __assert_fail ("StmtEntries.find(Record[0]) != StmtEntries.end() && \"No stmt was recorded for this offset reference!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2252, __PRETTY_FUNCTION__));
    S = StmtEntries[Record.readInt()];
    break;

  case STMT_NULL_PTR:
    S = nullptr;
    break;

  case STMT_NULL:
    S = new (Context) NullStmt(Empty);
    break;

  case STMT_COMPOUND:
    S = CompoundStmt::CreateEmpty(
        Context, /*NumStmts=*/Record[ASTStmtReader::NumStmtFields]);
    break;

  case STMT_CASE:
    S = new (Context) CaseStmt(Empty);
    break;

  case STMT_DEFAULT:
    S = new (Context) DefaultStmt(Empty);
    break;

  case STMT_LABEL:
    S = new (Context) LabelStmt(Empty);
    break;

  case STMT_ATTRIBUTED:
    S = AttributedStmt::CreateEmpty(
      Context,
      /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
    break;

  case STMT_IF:
    S = new (Context) IfStmt(Empty);
    break;

  case STMT_SWITCH:
    S = new (Context) SwitchStmt(Empty);
    break;

  case STMT_WHILE:
    S = new (Context) WhileStmt(Empty);
    break;

  case STMT_DO:
    S = new (Context) DoStmt(Empty);
    break;

  case STMT_FOR:
    S = new (Context) ForStmt(Empty);
    break;

  case STMT_GOTO:
    S = new (Context) GotoStmt(Empty);
    break;

  case STMT_INDIRECT_GOTO:
    S = new (Context) IndirectGotoStmt(Empty);
    break;

  case STMT_CONTINUE:
    S = new (Context) ContinueStmt(Empty);
    break;

  case STMT_BREAK:
    S = new (Context) BreakStmt(Empty);
    break;

  case STMT_RETURN:
    S = new (Context) ReturnStmt(Empty);
    break;

  case STMT_DECL:
    S = new (Context) DeclStmt(Empty);
    break;

  case STMT_GCCASM:
    S = new (Context) GCCAsmStmt(Empty);
    break;

  case STMT_MSASM:
    S = new (Context) MSAsmStmt(Empty);
    break;

  case STMT_CAPTURED:
    S = CapturedStmt::CreateDeserialized(
        Context, Record[ASTStmtReader::NumStmtFields]);
    break;

  case EXPR_PREDEFINED:
    S = PredefinedExpr::CreateEmpty(
        Context,
        /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_DECL_REF:
    S = DeclRefExpr::CreateEmpty(
      Context,
      /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
      /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
      /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
      /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
        Record[ASTStmtReader::NumExprFields + 5] : 0);
    break;

  case EXPR_INTEGER_LITERAL:
    S = IntegerLiteral::Create(Context, Empty);
    break;

  case EXPR_FLOATING_LITERAL:
    S = FloatingLiteral::Create(Context, Empty);
    break;

  case EXPR_IMAGINARY_LITERAL:
    S = new (Context) ImaginaryLiteral(Empty);
    break;

  case EXPR_STRING_LITERAL:
    S = StringLiteral::CreateEmpty(Context,
                                   Record[ASTStmtReader::NumExprFields + 1]);
    break;

  case EXPR_CHARACTER_LITERAL:
    S = new (Context) CharacterLiteral(Empty);
    break;

  case EXPR_PAREN:
    S = new (Context) ParenExpr(Empty);
    break;

  case EXPR_PAREN_LIST:
    S = new (Context) ParenListExpr(Empty);
    break;

  case EXPR_UNARY_OPERATOR:
    S = new (Context) UnaryOperator(Empty);
    break;

  case EXPR_OFFSETOF:
    S = OffsetOfExpr::CreateEmpty(Context,
                                  Record[ASTStmtReader::NumExprFields],
                                  Record[ASTStmtReader::NumExprFields + 1]);
    break;

  case EXPR_SIZEOF_ALIGN_OF:
    S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
    break;

  case EXPR_ARRAY_SUBSCRIPT:
    S = new (Context) ArraySubscriptExpr(Empty);
    break;

  case EXPR_OMP_ARRAY_SECTION:
    S = new (Context) OMPArraySectionExpr(Empty);
    break;

  case EXPR_CALL:
    S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
    break;

  case EXPR_MEMBER: {
    // We load everything here and fully initialize it at creation.
    // That way we can use MemberExpr::Create and don't have to duplicate its
    // logic with a MemberExpr::CreateEmpty.

    assert(Record.getIdx() == 0)((Record.getIdx() == 0) ? static_cast<void> (0) : __assert_fail
 ("Record.getIdx() == 0", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2420, __PRETTY_FUNCTION__));
    NestedNameSpecifierLoc QualifierLoc;
    if (Record.readInt()) { // HasQualifier.
      QualifierLoc = Record.readNestedNameSpecifierLoc();
    }

    SourceLocation TemplateKWLoc;
    TemplateArgumentListInfo ArgInfo;
    bool HasTemplateKWAndArgsInfo = Record.readInt();
    if (HasTemplateKWAndArgsInfo) {
      TemplateKWLoc = Record.readSourceLocation();
      unsigned NumTemplateArgs = Record.readInt();
      ArgInfo.setLAngleLoc(Record.readSourceLocation());
      ArgInfo.setRAngleLoc(Record.readSourceLocation());
      for (unsigned i = 0; i != NumTemplateArgs; ++i)
        ArgInfo.addArgument(Record.readTemplateArgumentLoc());
    }

    bool HadMultipleCandidates = Record.readInt();

    auto *FoundD = Record.readDeclAs<NamedDecl>();
    auto AS = (AccessSpecifier)Record.readInt();
    DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);

    QualType T = Record.readType();
    auto VK = static_cast<ExprValueKind>(Record.readInt());
    auto OK = static_cast<ExprObjectKind>(Record.readInt());
    Expr *Base = ReadSubExpr();
    auto *MemberD = Record.readDeclAs<ValueDecl>();
    SourceLocation MemberLoc = Record.readSourceLocation();
    DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
    bool IsArrow = Record.readInt();
    SourceLocation OperatorLoc = Record.readSourceLocation();

    S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,
                           TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
                           HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,
                           VK, OK);
    Record.readDeclarationNameLoc(cast<MemberExpr>(S)->MemberDNLoc,
                                  MemberD->getDeclName());
    if (HadMultipleCandidates)
      cast<MemberExpr>(S)->setHadMultipleCandidates(true);
    break;
  }

  case EXPR_BINARY_OPERATOR:
    S = new (Context) BinaryOperator(Empty);
    break;

  case EXPR_COMPOUND_ASSIGN_OPERATOR:
    S = new (Context) CompoundAssignOperator(Empty);
    break;

  case EXPR_CONDITIONAL_OPERATOR:
    S = new (Context) ConditionalOperator(Empty);
    break;

  case EXPR_BINARY_CONDITIONAL_OPERATOR:
    S = new (Context) BinaryConditionalOperator(Empty);
    break;

  case EXPR_IMPLICIT_CAST:
    S = ImplicitCastExpr::CreateEmpty(Context,
                     /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_CSTYLE_CAST:
    S = CStyleCastExpr::CreateEmpty(Context,
                     /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_COMPOUND_LITERAL:
    S = new (Context) CompoundLiteralExpr(Empty);
    break;

  case EXPR_EXT_VECTOR_ELEMENT:
    S = new (Context) ExtVectorElementExpr(Empty);
    break;

  case EXPR_INIT_LIST:
    S = new (Context) InitListExpr(Empty);
    break;

  case EXPR_DESIGNATED_INIT:
    S = DesignatedInitExpr::CreateEmpty(Context,
                                   Record[ASTStmtReader::NumExprFields] - 1);

    break;

  case EXPR_DESIGNATED_INIT_UPDATE:
    S = new (Context) DesignatedInitUpdateExpr(Empty);
    break;

  case EXPR_IMPLICIT_VALUE_INIT:
    S = new (Context) ImplicitValueInitExpr(Empty);
    break;

  case EXPR_NO_INIT:
    S = new (Context) NoInitExpr(Empty);
    break;

  case EXPR_ARRAY_INIT_LOOP:
    S = new (Context) ArrayInitLoopExpr(Empty);
    break;

  case EXPR_ARRAY_INIT_INDEX:
    S = new (Context) ArrayInitIndexExpr(Empty);
    break;

  case EXPR_VA_ARG:
    S = new (Context) VAArgExpr(Empty);
    break;

  case EXPR_ADDR_LABEL:
    S = new (Context) AddrLabelExpr(Empty);
    break;

  case EXPR_STMT:
    S = new (Context) StmtExpr(Empty);
    break;

  case EXPR_CHOOSE:
    S = new (Context) ChooseExpr(Empty);
    break;

  case EXPR_GNU_NULL:
    S = new (Context) GNUNullExpr(Empty);
    break;

  case EXPR_SHUFFLE_VECTOR:
    S = new (Context) ShuffleVectorExpr(Empty);
    break;

  case EXPR_CONVERT_VECTOR:
    S = new (Context) ConvertVectorExpr(Empty);
    break;

  case EXPR_BLOCK:
    S = new (Context) BlockExpr(Empty);
    break;

  case EXPR_GENERIC_SELECTION:
    S = new (Context) GenericSelectionExpr(Empty);
    break;

  case EXPR_OBJC_STRING_LITERAL:
    S = new (Context) ObjCStringLiteral(Empty);
    break;

  case EXPR_OBJC_BOXED_EXPRESSION:
    S = new (Context) ObjCBoxedExpr(Empty);
    break;

  case EXPR_OBJC_ARRAY_LITERAL:
    S = ObjCArrayLiteral::CreateEmpty(Context,
                                      Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_OBJC_DICTIONARY_LITERAL:
    S = ObjCDictionaryLiteral::CreateEmpty(Context,
          Record[ASTStmtReader::NumExprFields],
          Record[ASTStmtReader::NumExprFields + 1]);
    break;

  case EXPR_OBJC_ENCODE:
    S = new (Context) ObjCEncodeExpr(Empty);
    break;

  case EXPR_OBJC_SELECTOR_EXPR:
    S = new (Context) ObjCSelectorExpr(Empty);
    break;

  case EXPR_OBJC_PROTOCOL_EXPR:
    S = new (Context) ObjCProtocolExpr(Empty);
    break;

  case EXPR_OBJC_IVAR_REF_EXPR:
    S = new (Context) ObjCIvarRefExpr(Empty);
    break;

  case EXPR_OBJC_PROPERTY_REF_EXPR:
    S = new (Context) ObjCPropertyRefExpr(Empty);
    break;

  case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
    S = new (Context) ObjCSubscriptRefExpr(Empty);
    break;

  case EXPR_OBJC_KVC_REF_EXPR:
    llvm_unreachable("mismatching AST file")::llvm::llvm_unreachable_internal("mismatching AST file", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2609);

  case EXPR_OBJC_MESSAGE_EXPR:
    S = ObjCMessageExpr::CreateEmpty(Context,
                                   Record[ASTStmtReader::NumExprFields],
                                   Record[ASTStmtReader::NumExprFields + 1]);
    break;

  case EXPR_OBJC_ISA:
    S = new (Context) ObjCIsaExpr(Empty);
    break;

  case EXPR_OBJC_INDIRECT_COPY_RESTORE:
    S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
    break;

  case EXPR_OBJC_BRIDGED_CAST:
    S = new (Context) ObjCBridgedCastExpr(Empty);
    break;

  case STMT_OBJC_FOR_COLLECTION:
    S = new (Context) ObjCForCollectionStmt(Empty);
    break;

  case STMT_OBJC_CATCH:
    S = new (Context) ObjCAtCatchStmt(Empty);
    break;

  case STMT_OBJC_FINALLY:
    S = new (Context) ObjCAtFinallyStmt(Empty);
    break;

  case STMT_OBJC_AT_TRY:
    S = ObjCAtTryStmt::CreateEmpty(Context,
                                   Record[ASTStmtReader::NumStmtFields],
                                   Record[ASTStmtReader::NumStmtFields + 1]);
    break;

  case STMT_OBJC_AT_SYNCHRONIZED:
    S = new (Context) ObjCAtSynchronizedStmt(Empty);
    break;

  case STMT_OBJC_AT_THROW:
    S = new (Context) ObjCAtThrowStmt(Empty);
    break;

  case STMT_OBJC_AUTORELEASE_POOL:
    S = new (Context) ObjCAutoreleasePoolStmt(Empty);
    break;

  case EXPR_OBJC_BOOL_LITERAL:
    S = new (Context) ObjCBoolLiteralExpr(Empty);
    break;

  case EXPR_OBJC_AVAILABILITY_CHECK:
    S = new (Context) ObjCAvailabilityCheckExpr(Empty);
    break;

  case STMT_SEH_LEAVE:
    S = new (Context) SEHLeaveStmt(Empty);
    break;

  case STMT_SEH_EXCEPT:
    S = new (Context) SEHExceptStmt(Empty);
    break;

  case STMT_SEH_FINALLY:
    S = new (Context) SEHFinallyStmt(Empty);
    break;

  case STMT_SEH_TRY:
    S = new (Context) SEHTryStmt(Empty);
    break;

  case STMT_CXX_CATCH:
    S = new (Context) CXXCatchStmt(Empty);
    break;

  case STMT_CXX_TRY:
    S = CXXTryStmt::Create(Context, Empty,
           /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
    break;

  case STMT_CXX_FOR_RANGE:
    S = new (Context) CXXForRangeStmt(Empty);
    break;

  case STMT_MS_DEPENDENT_EXISTS:
    S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
                                            NestedNameSpecifierLoc(),
                                            DeclarationNameInfo(),
                                            nullptr);
    break;

  case STMT_OMP_PARALLEL_DIRECTIVE:
    S =
      OMPParallelDirective::CreateEmpty(Context,
                                        Record[ASTStmtReader::NumStmtFields],
                                        Empty);
    break;

  case STMT_OMP_SIMD_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
                                      CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_FOR_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                     Empty);
    break;
  }

  case STMT_OMP_FOR_SIMD_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                         Empty);
    break;
  }

  case STMT_OMP_SECTIONS_DIRECTIVE:
    S = OMPSectionsDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_SECTION_DIRECTIVE:
    S = OMPSectionDirective::CreateEmpty(Context, Empty);
    break;

  case STMT_OMP_SINGLE_DIRECTIVE:
    S = OMPSingleDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_MASTER_DIRECTIVE:
    S = OMPMasterDirective::CreateEmpty(Context, Empty);
    break;

  case STMT_OMP_CRITICAL_DIRECTIVE:
    S = OMPCriticalDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
                                             CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
                                                 CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
    S = OMPParallelSectionsDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TASK_DIRECTIVE:
    S = OMPTaskDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TASKYIELD_DIRECTIVE:
    S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
    break;

  case STMT_OMP_BARRIER_DIRECTIVE:
    S = OMPBarrierDirective::CreateEmpty(Context, Empty);
    break;

  case STMT_OMP_TASKWAIT_DIRECTIVE:
    S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
    break;

  case STMT_OMP_TASKGROUP_DIRECTIVE:
    S = OMPTaskgroupDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_FLUSH_DIRECTIVE:
    S = OMPFlushDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_ORDERED_DIRECTIVE:
    S = OMPOrderedDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_ATOMIC_DIRECTIVE:
    S = OMPAtomicDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TARGET_DIRECTIVE:
    S = OMPTargetDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TARGET_DATA_DIRECTIVE:
    S = OMPTargetDataDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE:
    S = OMPTargetEnterDataDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE:
    S = OMPTargetExitDataDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TARGET_PARALLEL_DIRECTIVE:
    S = OMPTargetParallelDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
                                                   CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TARGET_UPDATE_DIRECTIVE:
    S = OMPTargetUpdateDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TEAMS_DIRECTIVE:
    S = OMPTeamsDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
    S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
    break;

  case STMT_OMP_CANCEL_DIRECTIVE:
    S = OMPCancelDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TASKLOOP_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                          Empty);
    break;
  }

  case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
                                              CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                            Empty);
    break;
  }

  case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
                                                       CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPDistributeParallelForSimdDirective::CreateEmpty(Context, NumClauses,
                                                           CollapsedNum,
                                                           Empty);
    break;
  }

  case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
                                                CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
                                                       CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TARGET_SIMD_DIRECTIVE: {
    auto NumClauses = Record[ASTStmtReader::NumStmtFields];
    auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                            Empty);
    break;
  }

   case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: {
    auto NumClauses = Record[ASTStmtReader::NumStmtFields];
    auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
                                                 CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
    unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
    unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
                                                     CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
    auto NumClauses = Record[ASTStmtReader::NumStmtFields];
    auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(
        Context, NumClauses, CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
    auto NumClauses = Record[ASTStmtReader::NumStmtFields];
    auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTeamsDistributeParallelForDirective::CreateEmpty(
        Context, NumClauses, CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TARGET_TEAMS_DIRECTIVE:
    S = OMPTargetTeamsDirective::CreateEmpty(
        Context, Record[ASTStmtReader::NumStmtFields], Empty);
    break;

  case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: {
    auto NumClauses = Record[ASTStmtReader::NumStmtFields];
    auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
                                                       CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
    auto NumClauses = Record[ASTStmtReader::NumStmtFields];
    auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(
        Context, NumClauses, CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
    auto NumClauses = Record[ASTStmtReader::NumStmtFields];
    auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
        Context, NumClauses, CollapsedNum, Empty);
    break;
  }

  case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
    auto NumClauses = Record[ASTStmtReader::NumStmtFields];
    auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
    S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty(
        Context, NumClauses, CollapsedNum, Empty);
    break;
  }

  case EXPR_CXX_OPERATOR_CALL:
    S = new (Context) CXXOperatorCallExpr(Context, Empty);
    break;

  case EXPR_CXX_MEMBER_CALL:
    S = new (Context) CXXMemberCallExpr(Context, Empty);
    break;

  case EXPR_CXX_CONSTRUCT:
    S = new (Context) CXXConstructExpr(Empty);
    break;

  case EXPR_CXX_INHERITED_CTOR_INIT:
    S = new (Context) CXXInheritedCtorInitExpr(Empty);
    break;

  case EXPR_CXX_TEMPORARY_OBJECT:
    S = new (Context) CXXTemporaryObjectExpr(Empty);
    break;

  case EXPR_CXX_STATIC_CAST:
    S = CXXStaticCastExpr::CreateEmpty(Context,
                     /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_CXX_DYNAMIC_CAST:
    S = CXXDynamicCastExpr::CreateEmpty(Context,
                     /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_CXX_REINTERPRET_CAST:
    S = CXXReinterpretCastExpr::CreateEmpty(Context,
                     /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_CXX_CONST_CAST:
    S = CXXConstCastExpr::CreateEmpty(Context);
    break;

  case EXPR_CXX_FUNCTIONAL_CAST:
    S = CXXFunctionalCastExpr::CreateEmpty(Context,
                     /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_USER_DEFINED_LITERAL:
    S = new (Context) UserDefinedLiteral(Context, Empty);
    break;

  case EXPR_CXX_STD_INITIALIZER_LIST:
    S = new (Context) CXXStdInitializerListExpr(Empty);
    break;

  case EXPR_CXX_BOOL_LITERAL:
    S = new (Context) CXXBoolLiteralExpr(Empty);
    break;

  case EXPR_CXX_NULL_PTR_LITERAL:
    S = new (Context) CXXNullPtrLiteralExpr(Empty);
    break;

  case EXPR_CXX_TYPEID_EXPR:
    S = new (Context) CXXTypeidExpr(Empty, true);
    break;

  case EXPR_CXX_TYPEID_TYPE:
    S = new (Context) CXXTypeidExpr(Empty, false);
    break;

  case EXPR_CXX_UUIDOF_EXPR:
    S = new (Context) CXXUuidofExpr(Empty, true);
    break;

  case EXPR_CXX_PROPERTY_REF_EXPR:
    S = new (Context) MSPropertyRefExpr(Empty);
    break;

  case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
    S = new (Context) MSPropertySubscriptExpr(Empty);
    break;

  case EXPR_CXX_UUIDOF_TYPE:
    S = new (Context) CXXUuidofExpr(Empty, false);
    break;

  case EXPR_CXX_THIS:
    S = new (Context) CXXThisExpr(Empty);
    break;

  case EXPR_CXX_THROW:
    S = new (Context) CXXThrowExpr(Empty);
    break;

  case EXPR_CXX_DEFAULT_ARG:
    S = new (Context) CXXDefaultArgExpr(Empty);
    break;

  case EXPR_CXX_DEFAULT_INIT:
    S = new (Context) CXXDefaultInitExpr(Empty);
    break;

  case EXPR_CXX_BIND_TEMPORARY:
    S = new (Context) CXXBindTemporaryExpr(Empty);
    break;

  case EXPR_CXX_SCALAR_VALUE_INIT:
    S = new (Context) CXXScalarValueInitExpr(Empty);
    break;

  case EXPR_CXX_NEW:
    S = new (Context) CXXNewExpr(Empty);
    break;

  case EXPR_CXX_DELETE:
    S = new (Context) CXXDeleteExpr(Empty);
    break;

  case EXPR_CXX_PSEUDO_DESTRUCTOR:
    S = new (Context) CXXPseudoDestructorExpr(Empty);
    break;

  case EXPR_EXPR_WITH_CLEANUPS:
    S = ExprWithCleanups::Create(Context, Empty,
                                 Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
    S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
       /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
                /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
                                 ? Record[ASTStmtReader::NumExprFields + 1]
                                 : 0);
    break;

  case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
    S = DependentScopeDeclRefExpr::CreateEmpty(Context,
       /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
                /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
                                 ? Record[ASTStmtReader::NumExprFields + 1]
                                 : 0);
    break;

  case EXPR_CXX_UNRESOLVED_CONSTRUCT:
    S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
                            /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_CXX_UNRESOLVED_MEMBER:
    S = UnresolvedMemberExpr::CreateEmpty(Context,
       /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
                /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
                                 ? Record[ASTStmtReader::NumExprFields + 1]
                                 : 0);
    break;

  case EXPR_CXX_UNRESOLVED_LOOKUP:
    S = UnresolvedLookupExpr::CreateEmpty(Context,
       /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
                /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
                                 ? Record[ASTStmtReader::NumExprFields + 1]
                                 : 0);
    break;

  case EXPR_TYPE_TRAIT:
    S = TypeTraitExpr::CreateDeserialized(Context,
          Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_ARRAY_TYPE_TRAIT:
    S = new (Context) ArrayTypeTraitExpr(Empty);
    break;

  case EXPR_CXX_EXPRESSION_TRAIT:
    S = new (Context) ExpressionTraitExpr(Empty);
    break;

  case EXPR_CXX_NOEXCEPT:
    S = new (Context) CXXNoexceptExpr(Empty);
    break;

  case EXPR_PACK_EXPANSION:
    S = new (Context) PackExpansionExpr(Empty);
    break;

  case EXPR_SIZEOF_PACK:
    S = SizeOfPackExpr::CreateDeserialized(
            Context,
            /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
    S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
    break;

  case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
    S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
    break;

  case EXPR_FUNCTION_PARM_PACK:
    S = FunctionParmPackExpr::CreateEmpty(Context,
                                        Record[ASTStmtReader::NumExprFields]);
    break;

  case EXPR_MATERIALIZE_TEMPORARY:
    S = new (Context) MaterializeTemporaryExpr(Empty);
    break;

  case EXPR_CXX_FOLD:
    S = new (Context) CXXFoldExpr(Empty);
    break;

  case EXPR_OPAQUE_VALUE:
    S = new (Context) OpaqueValueExpr(Empty);
    break;

  case EXPR_CUDA_KERNEL_CALL:
    S = new (Context) CUDAKernelCallExpr(Context, Empty);
    break;

  case EXPR_ASTYPE:
    S = new (Context) AsTypeExpr(Empty);
    break;

  case EXPR_PSEUDO_OBJECT: {
    unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
    S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
    break;
  }

  case EXPR_ATOMIC:
    S = new (Context) AtomicExpr(Empty);
    break;

  case EXPR_LAMBDA: {
    unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
    S = LambdaExpr::CreateDeserialized(Context, NumCaptures);
    break;
  }

  case STMT_COROUTINE_BODY: {
    unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
    S = CoroutineBodyStmt::Create(Context, Empty, NumParams);
    break;
  }

  case STMT_CORETURN:
    S = new (Context) CoreturnStmt(Empty);
    break;

  case EXPR_COAWAIT:
    S = new (Context) CoawaitExpr(Empty);
    break;

  case EXPR_COYIELD:
    S = new (Context) CoyieldExpr(Empty);
    break;

  case EXPR_DEPENDENT_COAWAIT:
    S = new (Context) DependentCoawaitExpr(Empty);
    break;
  }

  // We hit a STMT_STOP, so we're done with this expression.
  if (Finished)
    break;

  ++NumStatementsRead;

  if (S && !IsStmtReference) {
    Reader.Visit(S);
    StmtEntries[Cursor.GetCurrentBitNo()] = S;
  }

  assert(Record.getIdx() == Record.size() &&((Record.getIdx() == Record.size() && "Invalid deserialization of statement"
) ? static_cast<void> (0) : __assert_fail ("Record.getIdx() == Record.size() && \"Invalid deserialization of statement\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3274, __PRETTY_FUNCTION__))
         "Invalid deserialization of statement")((Record.getIdx() == Record.size() && "Invalid deserialization of statement"
) ? static_cast<void> (0) : __assert_fail ("Record.getIdx() == Record.size() && \"Invalid deserialization of statement\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3274, __PRETTY_FUNCTION__));
  StmtStack.push_back(S);
}
3277Done:
assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!")((StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!"
) ? static_cast<void> (0) : __assert_fail ("StmtStack.size() > PrevNumStmts && \"Read too many sub-stmts!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3278, __PRETTY_FUNCTION__));
assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!")((StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"
) ? static_cast<void> (0) : __assert_fail ("StmtStack.size() == PrevNumStmts + 1 && \"Extra expressions on stack!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3279, __PRETTY_FUNCTION__));
return StmtStack.pop_back_val();
3281}