lib/Serialization/ASTReaderStmt.cpp

   1 //===--- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------*- C++ -*-===//
   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 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Serialization/ASTReader.h"
  16 #include "clang/AST/DeclCXX.h"
  17 #include "clang/AST/DeclTemplate.h"
  18 #include "clang/AST/StmtVisitor.h"
  19 using namespace clang;
  20 using namespace clang::serialization;
  21
  22 namespace clang {
  23
  24   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
  25     ASTReader &Reader;
  26     ASTReader::PerFileData &F;
  27     llvm::BitstreamCursor &DeclsCursor;
  28     const ASTReader::RecordData &Record;
  29     unsigned &Idx;
  30
  31     SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
  32                                       unsigned &I) {
  33       return Reader.ReadSourceLocation(F, R, I);
  34     }
  35     SourceRange ReadSourceRange(const ASTReader::RecordData &R, unsigned &I) {
  36       return Reader.ReadSourceRange(F, R, I);
  37     }
  38     TypeSourceInfo *GetTypeSourceInfo(const ASTReader::RecordData &R,
  39                                       unsigned &I) {
  40       return Reader.GetTypeSourceInfo(F, R, I);
  41     }
  42     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
  43                                 const ASTReader::RecordData &R, unsigned &I) {
  44       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
  45     }
  46     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
  47                                 const ASTReader::RecordData &R, unsigned &I) {
  48       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
  49     }
  50
  51   public:
  52     ASTStmtReader(ASTReader &Reader, ASTReader::PerFileData &F,
  53                   llvm::BitstreamCursor &Cursor,
  54                   const ASTReader::RecordData &Record, unsigned &Idx)
  55       : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
  56
  57     /// \brief The number of record fields required for the Stmt class
  58     /// itself.
  59     static const unsigned NumStmtFields = 0;
  60
  61     /// \brief The number of record fields required for the Expr class
  62     /// itself.
  63     static const unsigned NumExprFields = NumStmtFields + 6;
  64
  65     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
  66     void ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
  67                                           unsigned NumTemplateArgs);
  68
  69     void VisitStmt(Stmt *S);
  70     void VisitNullStmt(NullStmt *S);
  71     void VisitCompoundStmt(CompoundStmt *S);
  72     void VisitSwitchCase(SwitchCase *S);
  73     void VisitCaseStmt(CaseStmt *S);
  74     void VisitDefaultStmt(DefaultStmt *S);
  75     void VisitLabelStmt(LabelStmt *S);
  76     void VisitIfStmt(IfStmt *S);
  77     void VisitSwitchStmt(SwitchStmt *S);
  78     void VisitWhileStmt(WhileStmt *S);
  79     void VisitDoStmt(DoStmt *S);
  80     void VisitForStmt(ForStmt *S);
  81     void VisitGotoStmt(GotoStmt *S);
  82     void VisitIndirectGotoStmt(IndirectGotoStmt *S);
  83     void VisitContinueStmt(ContinueStmt *S);
  84     void VisitBreakStmt(BreakStmt *S);
  85     void VisitReturnStmt(ReturnStmt *S);
  86     void VisitDeclStmt(DeclStmt *S);
  87     void VisitAsmStmt(AsmStmt *S);
  88     void VisitExpr(Expr *E);
  89     void VisitPredefinedExpr(PredefinedExpr *E);
  90     void VisitDeclRefExpr(DeclRefExpr *E);
  91     void VisitIntegerLiteral(IntegerLiteral *E);
  92     void VisitFloatingLiteral(FloatingLiteral *E);
  93     void VisitImaginaryLiteral(ImaginaryLiteral *E);
  94     void VisitStringLiteral(StringLiteral *E);
  95     void VisitCharacterLiteral(CharacterLiteral *E);
  96     void VisitParenExpr(ParenExpr *E);
  97     void VisitParenListExpr(ParenListExpr *E);
  98     void VisitUnaryOperator(UnaryOperator *E);
  99     void VisitOffsetOfExpr(OffsetOfExpr *E);
 100     void VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E);
 101     void VisitArraySubscriptExpr(ArraySubscriptExpr *E);
 102     void VisitCallExpr(CallExpr *E);
 103     void VisitMemberExpr(MemberExpr *E);
 104     void VisitCastExpr(CastExpr *E);
 105     void VisitBinaryOperator(BinaryOperator *E);
 106     void VisitCompoundAssignOperator(CompoundAssignOperator *E);
 107     void VisitConditionalOperator(ConditionalOperator *E);
 108     void VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
 109     void VisitImplicitCastExpr(ImplicitCastExpr *E);
 110     void VisitExplicitCastExpr(ExplicitCastExpr *E);
 111     void VisitCStyleCastExpr(CStyleCastExpr *E);
 112     void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
 113     void VisitExtVectorElementExpr(ExtVectorElementExpr *E);
 114     void VisitInitListExpr(InitListExpr *E);
 115     void VisitDesignatedInitExpr(DesignatedInitExpr *E);
 116     void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
 117     void VisitVAArgExpr(VAArgExpr *E);
 118     void VisitAddrLabelExpr(AddrLabelExpr *E);
 119     void VisitStmtExpr(StmtExpr *E);
 120     void VisitChooseExpr(ChooseExpr *E);
 121     void VisitGNUNullExpr(GNUNullExpr *E);
 122     void VisitShuffleVectorExpr(ShuffleVectorExpr *E);
 123     void VisitBlockExpr(BlockExpr *E);
 124     void VisitBlockDeclRefExpr(BlockDeclRefExpr *E);
 125     void VisitObjCStringLiteral(ObjCStringLiteral *E);
 126     void VisitObjCEncodeExpr(ObjCEncodeExpr *E);
 127     void VisitObjCSelectorExpr(ObjCSelectorExpr *E);
 128     void VisitObjCProtocolExpr(ObjCProtocolExpr *E);
 129     void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E);
 130     void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
 131     void VisitObjCMessageExpr(ObjCMessageExpr *E);
 132     void VisitObjCIsaExpr(ObjCIsaExpr *E);
 133
 134     void VisitObjCForCollectionStmt(ObjCForCollectionStmt *);
 135     void VisitObjCAtCatchStmt(ObjCAtCatchStmt *);
 136     void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *);
 137     void VisitObjCAtTryStmt(ObjCAtTryStmt *);
 138     void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
 139     void VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
 140
 141     // C++ Statements
 142     void VisitCXXCatchStmt(CXXCatchStmt *S);
 143     void VisitCXXTryStmt(CXXTryStmt *S);
 144
 145     void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
 146     void VisitCXXConstructExpr(CXXConstructExpr *E);
 147     void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
 148     void VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
 149     void VisitCXXStaticCastExpr(CXXStaticCastExpr *E);
 150     void VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E);
 151     void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E);
 152     void VisitCXXConstCastExpr(CXXConstCastExpr *E);
 153     void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E);
 154     void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
 155     void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
 156     void VisitCXXTypeidExpr(CXXTypeidExpr *E);
 157     void VisitCXXUuidofExpr(CXXUuidofExpr *E);
 158     void VisitCXXThisExpr(CXXThisExpr *E);
 159     void VisitCXXThrowExpr(CXXThrowExpr *E);
 160     void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
 161     void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
 162
 163     void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
 164     void VisitCXXNewExpr(CXXNewExpr *E);
 165     void VisitCXXDeleteExpr(CXXDeleteExpr *E);
 166     void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
 167
 168     void VisitExprWithCleanups(ExprWithCleanups *E);
 169
 170     void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
 171     void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
 172     void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
 173
 174     void VisitOverloadExpr(OverloadExpr *E);
 175     void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
 176     void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
 177
 178     void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E);
 179     void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E);
 180     void VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
 181     void VisitPackExpansionExpr(PackExpansionExpr *E);
 182     void VisitSizeOfPackExpr(SizeOfPackExpr *E);
 183     void VisitSubstNonTypeTemplateParmPackExpr(
 184                                            SubstNonTypeTemplateParmPackExpr *E);
 185     void VisitOpaqueValueExpr(OpaqueValueExpr *E);
 186
 187     // CUDA Expressions
 188     void VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E);
 189   };
 190 }
 191
 192 void ASTStmtReader::
 193 ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
 194                                  unsigned NumTemplateArgs) {
 195   TemplateArgumentListInfo ArgInfo;
 196   ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
 197   ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
 198   for (unsigned i = 0; i != NumTemplateArgs; ++i)
 199     ArgInfo.addArgument(
 200         Reader.ReadTemplateArgumentLoc(F, Record, Idx));
 201   ArgList.initializeFrom(ArgInfo);
 202 }
 203
 204 void ASTStmtReader::VisitStmt(Stmt *S) {
 205   assert(Idx == NumStmtFields && "Incorrect statement field count");
 206 }
 207
 208 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
 209   VisitStmt(S);
 210   S->setSemiLoc(ReadSourceLocation(Record, Idx));
 211   S->LeadingEmptyMacro = Record[Idx++];
 212 }
 213
 214 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
 215   VisitStmt(S);
 216   llvm::SmallVector<Stmt *, 16> Stmts;
 217   unsigned NumStmts = Record[Idx++];
 218   while (NumStmts--)
 219     Stmts.push_back(Reader.ReadSubStmt());
 220   S->setStmts(*Reader.getContext(), Stmts.data(), Stmts.size());
 221   S->setLBracLoc(ReadSourceLocation(Record, Idx));
 222   S->setRBracLoc(ReadSourceLocation(Record, Idx));
 223 }
 224
 225 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
 226   VisitStmt(S);
 227   Reader.RecordSwitchCaseID(S, Record[Idx++]);
 228 }
 229
 230 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
 231   VisitSwitchCase(S);
 232   S->setLHS(Reader.ReadSubExpr());
 233   S->setRHS(Reader.ReadSubExpr());
 234   S->setSubStmt(Reader.ReadSubStmt());
 235   S->setCaseLoc(ReadSourceLocation(Record, Idx));
 236   S->setEllipsisLoc(ReadSourceLocation(Record, Idx));
 237   S->setColonLoc(ReadSourceLocation(Record, Idx));
 238 }
 239
 240 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
 241   VisitSwitchCase(S);
 242   S->setSubStmt(Reader.ReadSubStmt());
 243   S->setDefaultLoc(ReadSourceLocation(Record, Idx));
 244   S->setColonLoc(ReadSourceLocation(Record, Idx));
 245 }
 246
 247 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
 248   VisitStmt(S);
 249   LabelDecl *LD = cast<LabelDecl>(Reader.GetDecl(Record[Idx++]));
 250   LD->setStmt(S);
 251   S->setDecl(LD);
 252   S->setSubStmt(Reader.ReadSubStmt());
 253   S->setIdentLoc(ReadSourceLocation(Record, Idx));
 254 }
 255
 256 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
 257   VisitStmt(S);
 258   S->setConditionVariable(*Reader.getContext(),
 259                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 260   S->setCond(Reader.ReadSubExpr());
 261   S->setThen(Reader.ReadSubStmt());
 262   S->setElse(Reader.ReadSubStmt());
 263   S->setIfLoc(ReadSourceLocation(Record, Idx));
 264   S->setElseLoc(ReadSourceLocation(Record, Idx));
 265 }
 266
 267 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
 268   VisitStmt(S);
 269   S->setConditionVariable(*Reader.getContext(),
 270                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 271   S->setCond(Reader.ReadSubExpr());
 272   S->setBody(Reader.ReadSubStmt());
 273   S->setSwitchLoc(ReadSourceLocation(Record, Idx));
 274   if (Record[Idx++])
 275     S->setAllEnumCasesCovered();
 276
 277   SwitchCase *PrevSC = 0;
 278   for (unsigned N = Record.size(); Idx != N; ++Idx) {
 279     SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
 280     if (PrevSC)
 281       PrevSC->setNextSwitchCase(SC);
 282     else
 283       S->setSwitchCaseList(SC);
 284
 285     PrevSC = SC;
 286   }
 287 }
 288
 289 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
 290   VisitStmt(S);
 291   S->setConditionVariable(*Reader.getContext(),
 292                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 293   S->setCond(Reader.ReadSubExpr());
 294   S->setBody(Reader.ReadSubStmt());
 295   S->setWhileLoc(ReadSourceLocation(Record, Idx));
 296 }
 297
 298 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
 299   VisitStmt(S);
 300   S->setCond(Reader.ReadSubExpr());
 301   S->setBody(Reader.ReadSubStmt());
 302   S->setDoLoc(ReadSourceLocation(Record, Idx));
 303   S->setWhileLoc(ReadSourceLocation(Record, Idx));
 304   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 305 }
 306
 307 void ASTStmtReader::VisitForStmt(ForStmt *S) {
 308   VisitStmt(S);
 309   S->setInit(Reader.ReadSubStmt());
 310   S->setCond(Reader.ReadSubExpr());
 311   S->setConditionVariable(*Reader.getContext(),
 312                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 313   S->setInc(Reader.ReadSubExpr());
 314   S->setBody(Reader.ReadSubStmt());
 315   S->setForLoc(ReadSourceLocation(Record, Idx));
 316   S->setLParenLoc(ReadSourceLocation(Record, Idx));
 317   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 318 }
 319
 320 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
 321   VisitStmt(S);
 322   S->setLabel(cast<LabelDecl>(Reader.GetDecl(Record[Idx++])));
 323   S->setGotoLoc(ReadSourceLocation(Record, Idx));
 324   S->setLabelLoc(ReadSourceLocation(Record, Idx));
 325 }
 326
 327 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
 328   VisitStmt(S);
 329   S->setGotoLoc(ReadSourceLocation(Record, Idx));
 330   S->setStarLoc(ReadSourceLocation(Record, Idx));
 331   S->setTarget(Reader.ReadSubExpr());
 332 }
 333
 334 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
 335   VisitStmt(S);
 336   S->setContinueLoc(ReadSourceLocation(Record, Idx));
 337 }
 338
 339 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
 340   VisitStmt(S);
 341   S->setBreakLoc(ReadSourceLocation(Record, Idx));
 342 }
 343
 344 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
 345   VisitStmt(S);
 346   S->setRetValue(Reader.ReadSubExpr());
 347   S->setReturnLoc(ReadSourceLocation(Record, Idx));
 348   S->setNRVOCandidate(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 349 }
 350
 351 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
 352   VisitStmt(S);
 353   S->setStartLoc(ReadSourceLocation(Record, Idx));
 354   S->setEndLoc(ReadSourceLocation(Record, Idx));
 355
 356   if (Idx + 1 == Record.size()) {
 357     // Single declaration
 358     S->setDeclGroup(DeclGroupRef(Reader.GetDecl(Record[Idx++])));
 359   } else {
 360     llvm::SmallVector<Decl *, 16> Decls;
 361     Decls.reserve(Record.size() - Idx);
 362     for (unsigned N = Record.size(); Idx != N; ++Idx)
 363       Decls.push_back(Reader.GetDecl(Record[Idx]));
 364     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(*Reader.getContext(),
 365                                                    Decls.data(),
 366                                                    Decls.size())));
 367   }
 368 }
 369
 370 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
 371   VisitStmt(S);
 372   unsigned NumOutputs = Record[Idx++];
 373   unsigned NumInputs = Record[Idx++];
 374   unsigned NumClobbers = Record[Idx++];
 375   S->setAsmLoc(ReadSourceLocation(Record, Idx));
 376   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 377   S->setVolatile(Record[Idx++]);
 378   S->setSimple(Record[Idx++]);
 379   S->setMSAsm(Record[Idx++]);
 380
 381   S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 382
 383   // Outputs and inputs
 384   llvm::SmallVector<IdentifierInfo *, 16> Names;
 385   llvm::SmallVector<StringLiteral*, 16> Constraints;
 386   llvm::SmallVector<Stmt*, 16> Exprs;
 387   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
 388     Names.push_back(Reader.GetIdentifierInfo(Record, Idx));
 389     Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 390     Exprs.push_back(Reader.ReadSubStmt());
 391   }
 392
 393   // Constraints
 394   llvm::SmallVector<StringLiteral*, 16> Clobbers;
 395   for (unsigned I = 0; I != NumClobbers; ++I)
 396     Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 397
 398   S->setOutputsAndInputsAndClobbers(*Reader.getContext(),
 399                                     Names.data(), Constraints.data(),
 400                                     Exprs.data(), NumOutputs, NumInputs,
 401                                     Clobbers.data(), NumClobbers);
 402 }
 403
 404 void ASTStmtReader::VisitExpr(Expr *E) {
 405   VisitStmt(E);
 406   E->setType(Reader.GetType(Record[Idx++]));
 407   E->setTypeDependent(Record[Idx++]);
 408   E->setValueDependent(Record[Idx++]);
 409   E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];
 410   E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
 411   E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
 412   assert(Idx == NumExprFields && "Incorrect expression field count");
 413 }
 414
 415 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
 416   VisitExpr(E);
 417   E->setLocation(ReadSourceLocation(Record, Idx));
 418   E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
 419 }
 420
 421 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
 422   VisitExpr(E);
 423
 424   bool HasQualifier = Record[Idx++];
 425   bool HasExplicitTemplateArgs = Record[Idx++];
 426
 427   E->DecoratedD.setInt((HasQualifier? DeclRefExpr::HasQualifierFlag : 0) |
 428       (HasExplicitTemplateArgs
 429          ? DeclRefExpr::HasExplicitTemplateArgumentListFlag : 0));
 430
 431   if (HasQualifier) {
 432     E->getNameQualifier()->NNS = Reader.ReadNestedNameSpecifier(Record, Idx);
 433     E->getNameQualifier()->Range = ReadSourceRange(Record, Idx);
 434   }
 435
 436   if (HasExplicitTemplateArgs) {
 437     unsigned NumTemplateArgs = Record[Idx++];
 438     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
 439                                      NumTemplateArgs);
 440   }
 441
 442   E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
 443   E->setLocation(ReadSourceLocation(Record, Idx));
 444   ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);
 445 }
 446
 447 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
 448   VisitExpr(E);
 449   E->setLocation(ReadSourceLocation(Record, Idx));
 450   E->setValue(*Reader.getContext(), Reader.ReadAPInt(Record, Idx));
 451 }
 452
 453 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
 454   VisitExpr(E);
 455   E->setValue(*Reader.getContext(), Reader.ReadAPFloat(Record, Idx));
 456   E->setExact(Record[Idx++]);
 457   E->setLocation(ReadSourceLocation(Record, Idx));
 458 }
 459
 460 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
 461   VisitExpr(E);
 462   E->setSubExpr(Reader.ReadSubExpr());
 463 }
 464
 465 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
 466   VisitExpr(E);
 467   unsigned Len = Record[Idx++];
 468   assert(Record[Idx] == E->getNumConcatenated() &&
 469          "Wrong number of concatenated tokens!");
 470   ++Idx;
 471   E->setWide(Record[Idx++]);
 472
 473   // Read string data
 474   llvm::SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
 475   E->setString(*Reader.getContext(), Str.str());
 476   Idx += Len;
 477
 478   // Read source locations
 479   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
 480     E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));
 481 }
 482
 483 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
 484   VisitExpr(E);
 485   E->setValue(Record[Idx++]);
 486   E->setLocation(ReadSourceLocation(Record, Idx));
 487   E->setWide(Record[Idx++]);
 488 }
 489
 490 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
 491   VisitExpr(E);
 492   E->setLParen(ReadSourceLocation(Record, Idx));
 493   E->setRParen(ReadSourceLocation(Record, Idx));
 494   E->setSubExpr(Reader.ReadSubExpr());
 495 }
 496
 497 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
 498   VisitExpr(E);
 499   unsigned NumExprs = Record[Idx++];
 500   E->Exprs = new (*Reader.getContext()) Stmt*[NumExprs];
 501   for (unsigned i = 0; i != NumExprs; ++i)
 502     E->Exprs[i] = Reader.ReadSubStmt();
 503   E->NumExprs = NumExprs;
 504   E->LParenLoc = ReadSourceLocation(Record, Idx);
 505   E->RParenLoc = ReadSourceLocation(Record, Idx);
 506 }
 507
 508 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
 509   VisitExpr(E);
 510   E->setSubExpr(Reader.ReadSubExpr());
 511   E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
 512   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 513 }
 514
 515 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
 516   typedef OffsetOfExpr::OffsetOfNode Node;
 517   VisitExpr(E);
 518   assert(E->getNumComponents() == Record[Idx]);
 519   ++Idx;
 520   assert(E->getNumExpressions() == Record[Idx]);
 521   ++Idx;
 522   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 523   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 524   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 525   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
 526     Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
 527     SourceLocation Start = ReadSourceLocation(Record, Idx);
 528     SourceLocation End = ReadSourceLocation(Record, Idx);
 529     switch (Kind) {
 530     case Node::Array:
 531       E->setComponent(I, Node(Start, Record[Idx++], End));
 532       break;
 533
 534     case Node::Field:
 535       E->setComponent(I,
 536              Node(Start,
 537                   dyn_cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])),
 538                   End));
 539       break;
 540
 541     case Node::Identifier:
 542       E->setComponent(I, Node(Start, Reader.GetIdentifier(Record[Idx++]), End));
 543       break;
 544
 545     case Node::Base: {
 546       CXXBaseSpecifier *Base = new (*Reader.getContext()) CXXBaseSpecifier();
 547       *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
 548       E->setComponent(I, Node(Base));
 549       break;
 550     }
 551     }
 552   }
 553
 554   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
 555     E->setIndexExpr(I, Reader.ReadSubExpr());
 556 }
 557
 558 void ASTStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
 559   VisitExpr(E);
 560   E->setSizeof(Record[Idx++]);
 561   if (Record[Idx] == 0) {
 562     E->setArgument(Reader.ReadSubExpr());
 563     ++Idx;
 564   } else {
 565     E->setArgument(GetTypeSourceInfo(Record, Idx));
 566   }
 567   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 568   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 569 }
 570
 571 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 572   VisitExpr(E);
 573   E->setLHS(Reader.ReadSubExpr());
 574   E->setRHS(Reader.ReadSubExpr());
 575   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
 576 }
 577
 578 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
 579   VisitExpr(E);
 580   E->setNumArgs(*Reader.getContext(), Record[Idx++]);
 581   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 582   E->setCallee(Reader.ReadSubExpr());
 583   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
 584     E->setArg(I, Reader.ReadSubExpr());
 585 }
 586
 587 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
 588   // Don't call VisitExpr, this is fully initialized at creation.
 589   assert(E->getStmtClass() == Stmt::MemberExprClass &&
 590          "It's a subclass, we must advance Idx!");
 591 }
 592
 593 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
 594   VisitExpr(E);
 595   E->setBase(Reader.ReadSubExpr());
 596   E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));
 597   E->setArrow(Record[Idx++]);
 598 }
 599
 600 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
 601   VisitExpr(E);
 602   unsigned NumBaseSpecs = Record[Idx++];
 603   assert(NumBaseSpecs == E->path_size());
 604   E->setSubExpr(Reader.ReadSubExpr());
 605   E->setCastKind((CastExpr::CastKind)Record[Idx++]);
 606   CastExpr::path_iterator BaseI = E->path_begin();
 607   while (NumBaseSpecs--) {
 608     CXXBaseSpecifier *BaseSpec = new (*Reader.getContext()) CXXBaseSpecifier;
 609     *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
 610     *BaseI++ = BaseSpec;
 611   }
 612 }
 613
 614 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
 615   VisitExpr(E);
 616   E->setLHS(Reader.ReadSubExpr());
 617   E->setRHS(Reader.ReadSubExpr());
 618   E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
 619   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 620 }
 621
 622 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 623   VisitBinaryOperator(E);
 624   E->setComputationLHSType(Reader.GetType(Record[Idx++]));
 625   E->setComputationResultType(Reader.GetType(Record[Idx++]));
 626 }
 627
 628 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
 629   VisitExpr(E);
 630   E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr();
 631   E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr();
 632   E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr();
 633   E->QuestionLoc = ReadSourceLocation(Record, Idx);
 634   E->ColonLoc = ReadSourceLocation(Record, Idx);
 635 }
 636
 637 void
 638 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
 639   VisitExpr(E);
 640   E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr());
 641   E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr();
 642   E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr();
 643   E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr();
 644   E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr();
 645   E->QuestionLoc = ReadSourceLocation(Record, Idx);
 646   E->ColonLoc = ReadSourceLocation(Record, Idx);
 647
 648   E->getOpaqueValue()->setSourceExpr(E->getCommon());
 649 }
 650
 651 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
 652   VisitCastExpr(E);
 653 }
 654
 655 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
 656   VisitCastExpr(E);
 657   E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));
 658 }
 659
 660 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
 661   VisitExplicitCastExpr(E);
 662   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 663   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 664 }
 665
 666 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 667   VisitExpr(E);
 668   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 669   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 670   E->setInitializer(Reader.ReadSubExpr());
 671   E->setFileScope(Record[Idx++]);
 672 }
 673
 674 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
 675   VisitExpr(E);
 676   E->setBase(Reader.ReadSubExpr());
 677   E->setAccessor(Reader.GetIdentifierInfo(Record, Idx));
 678   E->setAccessorLoc(ReadSourceLocation(Record, Idx));
 679 }
 680
 681 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
 682   VisitExpr(E);
 683   unsigned NumInits = Record[Idx++];
 684   E->reserveInits(*Reader.getContext(), NumInits);
 685   for (unsigned I = 0; I != NumInits; ++I)
 686     E->updateInit(*Reader.getContext(), I, Reader.ReadSubExpr());
 687   E->setSyntacticForm(cast_or_null<InitListExpr>(Reader.ReadSubStmt()));
 688   E->setLBraceLoc(ReadSourceLocation(Record, Idx));
 689   E->setRBraceLoc(ReadSourceLocation(Record, Idx));
 690   E->setInitializedFieldInUnion(
 691                       cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])));
 692   E->sawArrayRangeDesignator(Record[Idx++]);
 693 }
 694
 695 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
 696   typedef DesignatedInitExpr::Designator Designator;
 697
 698   VisitExpr(E);
 699   unsigned NumSubExprs = Record[Idx++];
 700   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
 701   for (unsigned I = 0; I != NumSubExprs; ++I)
 702     E->setSubExpr(I, Reader.ReadSubExpr());
 703   E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));
 704   E->setGNUSyntax(Record[Idx++]);
 705
 706   llvm::SmallVector<Designator, 4> Designators;
 707   while (Idx < Record.size()) {
 708     switch ((DesignatorTypes)Record[Idx++]) {
 709     case DESIG_FIELD_DECL: {
 710       FieldDecl *Field = cast<FieldDecl>(Reader.GetDecl(Record[Idx++]));
 711       SourceLocation DotLoc
 712         = ReadSourceLocation(Record, Idx);
 713       SourceLocation FieldLoc
 714         = ReadSourceLocation(Record, Idx);
 715       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
 716                                        FieldLoc));
 717       Designators.back().setField(Field);
 718       break;
 719     }
 720
 721     case DESIG_FIELD_NAME: {
 722       const IdentifierInfo *Name = Reader.GetIdentifierInfo(Record, Idx);
 723       SourceLocation DotLoc
 724         = ReadSourceLocation(Record, Idx);
 725       SourceLocation FieldLoc
 726         = ReadSourceLocation(Record, Idx);
 727       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
 728       break;
 729     }
 730
 731     case DESIG_ARRAY: {
 732       unsigned Index = Record[Idx++];
 733       SourceLocation LBracketLoc
 734         = ReadSourceLocation(Record, Idx);
 735       SourceLocation RBracketLoc
 736         = ReadSourceLocation(Record, Idx);
 737       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
 738       break;
 739     }
 740
 741     case DESIG_ARRAY_RANGE: {
 742       unsigned Index = Record[Idx++];
 743       SourceLocation LBracketLoc
 744         = ReadSourceLocation(Record, Idx);
 745       SourceLocation EllipsisLoc
 746         = ReadSourceLocation(Record, Idx);
 747       SourceLocation RBracketLoc
 748         = ReadSourceLocation(Record, Idx);
 749       Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
 750                                        RBracketLoc));
 751       break;
 752     }
 753     }
 754   }
 755   E->setDesignators(*Reader.getContext(),
 756                     Designators.data(), Designators.size());
 757 }
 758
 759 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 760   VisitExpr(E);
 761 }
 762
 763 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
 764   VisitExpr(E);
 765   E->setSubExpr(Reader.ReadSubExpr());
 766   E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));
 767   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 768   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 769 }
 770
 771 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
 772   VisitExpr(E);
 773   E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));
 774   E->setLabelLoc(ReadSourceLocation(Record, Idx));
 775   E->setLabel(cast<LabelDecl>(Reader.GetDecl(Record[Idx++])));
 776 }
 777
 778 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
 779   VisitExpr(E);
 780   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 781   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 782   E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
 783 }
 784
 785 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
 786   VisitExpr(E);
 787   E->setCond(Reader.ReadSubExpr());
 788   E->setLHS(Reader.ReadSubExpr());
 789   E->setRHS(Reader.ReadSubExpr());
 790   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 791   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 792 }
 793
 794 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
 795   VisitExpr(E);
 796   E->setTokenLocation(ReadSourceLocation(Record, Idx));
 797 }
 798
 799 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
 800   VisitExpr(E);
 801   llvm::SmallVector<Expr *, 16> Exprs;
 802   unsigned NumExprs = Record[Idx++];
 803   while (NumExprs--)
 804     Exprs.push_back(Reader.ReadSubExpr());
 805   E->setExprs(*Reader.getContext(), Exprs.data(), Exprs.size());
 806   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 807   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 808 }
 809
 810 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
 811   VisitExpr(E);
 812   E->setBlockDecl(cast_or_null<BlockDecl>(Reader.GetDecl(Record[Idx++])));
 813 }
 814
 815 void ASTStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
 816   VisitExpr(E);
 817   E->setDecl(cast<VarDecl>(Reader.GetDecl(Record[Idx++])));
 818   E->setLocation(ReadSourceLocation(Record, Idx));
 819   E->setByRef(Record[Idx++]);
 820   E->setConstQualAdded(Record[Idx++]);
 821 }
 822
 823 //===----------------------------------------------------------------------===//
 824 // Objective-C Expressions and Statements
 825
 826 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
 827   VisitExpr(E);
 828   E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
 829   E->setAtLoc(ReadSourceLocation(Record, Idx));
 830 }
 831
 832 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
 833   VisitExpr(E);
 834   E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 835   E->setAtLoc(ReadSourceLocation(Record, Idx));
 836   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 837 }
 838
 839 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
 840   VisitExpr(E);
 841   E->setSelector(Reader.GetSelector(Record, Idx));
 842   E->setAtLoc(ReadSourceLocation(Record, Idx));
 843   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 844 }
 845
 846 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
 847   VisitExpr(E);
 848   E->setProtocol(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
 849   E->setAtLoc(ReadSourceLocation(Record, Idx));
 850   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 851 }
 852
 853 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
 854   VisitExpr(E);
 855   E->setDecl(cast<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
 856   E->setLocation(ReadSourceLocation(Record, Idx));
 857   E->setBase(Reader.ReadSubExpr());
 858   E->setIsArrow(Record[Idx++]);
 859   E->setIsFreeIvar(Record[Idx++]);
 860 }
 861
 862 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
 863   VisitExpr(E);
 864   bool Implicit = Record[Idx++] != 0;
 865   if (Implicit) {
 866     ObjCMethodDecl *Getter =
 867       cast<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]));
 868     ObjCMethodDecl *Setter =
 869       cast<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]));
 870     E->setImplicitProperty(Getter, Setter);
 871   } else {
 872     E->setExplicitProperty(
 873                       cast<ObjCPropertyDecl>(Reader.GetDecl(Record[Idx++])));
 874   }
 875   E->setLocation(ReadSourceLocation(Record, Idx));
 876   E->setReceiverLocation(ReadSourceLocation(Record, Idx));
 877   switch (Record[Idx++]) {
 878   case 0:
 879     E->setBase(Reader.ReadSubExpr());
 880     break;
 881   case 1:
 882     E->setSuperReceiver(Reader.GetType(Record[Idx++]));
 883     break;
 884   case 2:
 885     E->setClassReceiver(
 886                      cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
 887     break;
 888   }
 889 }
 890
 891 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
 892   VisitExpr(E);
 893   assert(Record[Idx] == E->getNumArgs());
 894   ++Idx;
 895   ObjCMessageExpr::ReceiverKind Kind
 896     = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
 897   switch (Kind) {
 898   case ObjCMessageExpr::Instance:
 899     E->setInstanceReceiver(Reader.ReadSubExpr());
 900     break;
 901
 902   case ObjCMessageExpr::Class:
 903     E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
 904     break;
 905
 906   case ObjCMessageExpr::SuperClass:
 907   case ObjCMessageExpr::SuperInstance: {
 908     QualType T = Reader.GetType(Record[Idx++]);
 909     SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
 910     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
 911     break;
 912   }
 913   }
 914
 915   assert(Kind == E->getReceiverKind());
 916
 917   if (Record[Idx++])
 918     E->setMethodDecl(cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
 919   else
 920     E->setSelector(Reader.GetSelector(Record, Idx));
 921
 922   E->LBracLoc = ReadSourceLocation(Record, Idx);
 923   E->RBracLoc = ReadSourceLocation(Record, Idx);
 924   E->SelectorLoc = ReadSourceLocation(Record, Idx);
 925
 926   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
 927     E->setArg(I, Reader.ReadSubExpr());
 928 }
 929
 930 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
 931   VisitStmt(S);
 932   S->setElement(Reader.ReadSubStmt());
 933   S->setCollection(Reader.ReadSubExpr());
 934   S->setBody(Reader.ReadSubStmt());
 935   S->setForLoc(ReadSourceLocation(Record, Idx));
 936   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 937 }
 938
 939 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
 940   VisitStmt(S);
 941   S->setCatchBody(Reader.ReadSubStmt());
 942   S->setCatchParamDecl(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 943   S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
 944   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 945 }
 946
 947 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
 948   VisitStmt(S);
 949   S->setFinallyBody(Reader.ReadSubStmt());
 950   S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
 951 }
 952
 953 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
 954   VisitStmt(S);
 955   assert(Record[Idx] == S->getNumCatchStmts());
 956   ++Idx;
 957   bool HasFinally = Record[Idx++];
 958   S->setTryBody(Reader.ReadSubStmt());
 959   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
 960     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
 961
 962   if (HasFinally)
 963     S->setFinallyStmt(Reader.ReadSubStmt());
 964   S->setAtTryLoc(ReadSourceLocation(Record, Idx));
 965 }
 966
 967 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
 968   VisitStmt(S);
 969   S->setSynchExpr(Reader.ReadSubStmt());
 970   S->setSynchBody(Reader.ReadSubStmt());
 971   S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
 972 }
 973
 974 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
 975   VisitStmt(S);
 976   S->setThrowExpr(Reader.ReadSubStmt());
 977   S->setThrowLoc(ReadSourceLocation(Record, Idx));
 978 }
 979
 980 //===----------------------------------------------------------------------===//
 981 // C++ Expressions and Statements
 982 //===----------------------------------------------------------------------===//
 983
 984 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
 985   VisitStmt(S);
 986   S->CatchLoc = ReadSourceLocation(Record, Idx);
 987   S->ExceptionDecl = cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++]));
 988   S->HandlerBlock = Reader.ReadSubStmt();
 989 }
 990
 991 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
 992   VisitStmt(S);
 993   assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
 994   ++Idx;
 995   S->TryLoc = ReadSourceLocation(Record, Idx);
 996   S->getStmts()[0] = Reader.ReadSubStmt();
 997   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
 998     S->getStmts()[i + 1] = Reader.ReadSubStmt();
 999 }
1000
1001 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1002   VisitCallExpr(E);
1003   E->setOperator((OverloadedOperatorKind)Record[Idx++]);
1004 }
1005
1006 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1007   VisitExpr(E);
1008   E->NumArgs = Record[Idx++];
1009   if (E->NumArgs)
1010     E->Args = new (*Reader.getContext()) Stmt*[E->NumArgs];
1011   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1012     E->setArg(I, Reader.ReadSubExpr());
1013   E->setConstructor(cast<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
1014   E->setLocation(ReadSourceLocation(Record, Idx));
1015   E->setElidable(Record[Idx++]);
1016   E->setRequiresZeroInitialization(Record[Idx++]);
1017   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
1018   E->ParenRange = ReadSourceRange(Record, Idx);
1019 }
1020
1021 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1022   VisitCXXConstructExpr(E);
1023   E->Type = GetTypeSourceInfo(Record, Idx);
1024 }
1025
1026 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1027   VisitExplicitCastExpr(E);
1028   SourceRange R = ReadSourceRange(Record, Idx);
1029   E->Loc = R.getBegin();
1030   E->RParenLoc = R.getEnd();
1031 }
1032
1033 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1034   return VisitCXXNamedCastExpr(E);
1035 }
1036
1037 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1038   return VisitCXXNamedCastExpr(E);
1039 }
1040
1041 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1042   return VisitCXXNamedCastExpr(E);
1043 }
1044
1045 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1046   return VisitCXXNamedCastExpr(E);
1047 }
1048
1049 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1050   VisitExplicitCastExpr(E);
1051   E->setTypeBeginLoc(ReadSourceLocation(Record, Idx));
1052   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1053 }
1054
1055 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1056   VisitExpr(E);
1057   E->setValue(Record[Idx++]);
1058   E->setLocation(ReadSourceLocation(Record, Idx));
1059 }
1060
1061 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1062   VisitExpr(E);
1063   E->setLocation(ReadSourceLocation(Record, Idx));
1064 }
1065
1066 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1067   VisitExpr(E);
1068   E->setSourceRange(ReadSourceRange(Record, Idx));
1069   if (E->isTypeOperand()) { // typeid(int)
1070     E->setTypeOperandSourceInfo(
1071         GetTypeSourceInfo(Record, Idx));
1072     return;
1073   }
1074
1075   // typeid(42+2)
1076   E->setExprOperand(Reader.ReadSubExpr());
1077 }
1078 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1079   VisitExpr(E);
1080   E->setSourceRange(ReadSourceRange(Record, Idx));
1081   if (E->isTypeOperand()) { // __uuidof(ComType)
1082     E->setTypeOperandSourceInfo(
1083         GetTypeSourceInfo(Record, Idx));
1084     return;
1085   }
1086
1087   // __uuidof(expr)
1088   E->setExprOperand(Reader.ReadSubExpr());
1089 }
1090
1091 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1092   VisitExpr(E);
1093   E->setLocation(ReadSourceLocation(Record, Idx));
1094   E->setImplicit(Record[Idx++]);
1095 }
1096
1097 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1098   VisitExpr(E);
1099   E->setThrowLoc(ReadSourceLocation(Record, Idx));
1100   E->setSubExpr(Reader.ReadSubExpr());
1101 }
1102
1103 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1104   VisitExpr(E);
1105
1106   assert(Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1107   ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1108   E->Param.setPointer(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
1109   E->Loc = ReadSourceLocation(Record, Idx);
1110 }
1111
1112 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1113   VisitExpr(E);
1114   E->setTemporary(Reader.ReadCXXTemporary(Record, Idx));
1115   E->setSubExpr(Reader.ReadSubExpr());
1116 }
1117
1118 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1119   VisitExpr(E);
1120   E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1121   E->RParenLoc = ReadSourceLocation(Record, Idx);
1122 }
1123
1124 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1125   VisitExpr(E);
1126   E->GlobalNew = Record[Idx++];
1127   E->Initializer = Record[Idx++];
1128   E->UsualArrayDeleteWantsSize = Record[Idx++];
1129   bool isArray = Record[Idx++];
1130   unsigned NumPlacementArgs = Record[Idx++];
1131   unsigned NumCtorArgs = Record[Idx++];
1132   E->setOperatorNew(cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1133   E->setOperatorDelete(
1134                     cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1135   E->setConstructor(
1136                cast_or_null<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
1137   E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1138   SourceRange TypeIdParens;
1139   TypeIdParens.setBegin(ReadSourceLocation(Record, Idx));
1140   TypeIdParens.setEnd(ReadSourceLocation(Record, Idx));
1141   E->TypeIdParens = TypeIdParens;
1142   E->StartLoc = ReadSourceLocation(Record, Idx);
1143   E->EndLoc = ReadSourceLocation(Record, Idx);
1144   E->ConstructorLParen = ReadSourceLocation(Record, Idx);
1145   E->ConstructorRParen = ReadSourceLocation(Record, Idx);
1146
1147   E->AllocateArgsArray(*Reader.getContext(), isArray, NumPlacementArgs,
1148                        NumCtorArgs);
1149
1150   // Install all the subexpressions.
1151   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1152        I != e; ++I)
1153     *I = Reader.ReadSubStmt();
1154 }
1155
1156 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1157   VisitExpr(E);
1158   E->GlobalDelete = Record[Idx++];
1159   E->ArrayForm = Record[Idx++];
1160   E->ArrayFormAsWritten = Record[Idx++];
1161   E->UsualArrayDeleteWantsSize = Record[Idx++];
1162   E->OperatorDelete = cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++]));
1163   E->Argument = Reader.ReadSubExpr();
1164   E->Loc = ReadSourceLocation(Record, Idx);
1165 }
1166
1167 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1168   VisitExpr(E);
1169
1170   E->setBase(Reader.ReadSubExpr());
1171   E->setArrow(Record[Idx++]);
1172   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
1173   E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1174   E->setQualifierRange(ReadSourceRange(Record, Idx));
1175   E->setScopeTypeInfo(GetTypeSourceInfo(Record, Idx));
1176   E->setColonColonLoc(ReadSourceLocation(Record, Idx));
1177   E->setTildeLoc(ReadSourceLocation(Record, Idx));
1178
1179   IdentifierInfo *II = Reader.GetIdentifierInfo(Record, Idx);
1180   if (II)
1181     E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1182   else
1183     E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1184 }
1185
1186 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1187   VisitExpr(E);
1188   unsigned NumTemps = Record[Idx++];
1189   if (NumTemps) {
1190     E->setNumTemporaries(*Reader.getContext(), NumTemps);
1191     for (unsigned i = 0; i != NumTemps; ++i)
1192       E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx));
1193   }
1194   E->setSubExpr(Reader.ReadSubExpr());
1195 }
1196
1197 void
1198 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1199   VisitExpr(E);
1200
1201   if (Record[Idx++])
1202     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1203                                      Record[Idx++]);
1204
1205   E->setBase(Reader.ReadSubExpr());
1206   E->setBaseType(Reader.GetType(Record[Idx++]));
1207   E->setArrow(Record[Idx++]);
1208   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
1209   E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1210   E->setQualifierRange(ReadSourceRange(Record, Idx));
1211   E->setFirstQualifierFoundInScope(
1212                         cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++])));
1213   ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1214 }
1215
1216 void
1217 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1218   VisitExpr(E);
1219
1220   if (Record[Idx++])
1221     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1222                                      Record[Idx++]);
1223
1224   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1225   E->setQualifierRange(ReadSourceRange(Record, Idx));
1226   E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1227 }
1228
1229 void
1230 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1231   VisitExpr(E);
1232   assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1233   ++Idx; // NumArgs;
1234   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1235     E->setArg(I, Reader.ReadSubExpr());
1236   E->Type = GetTypeSourceInfo(Record, Idx);
1237   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1238   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1239 }
1240
1241 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1242   VisitExpr(E);
1243
1244   // Read the explicit template argument list, if available.
1245   if (Record[Idx++])
1246     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1247                                      Record[Idx++]);
1248
1249   unsigned NumDecls = Record[Idx++];
1250   UnresolvedSet<8> Decls;
1251   for (unsigned i = 0; i != NumDecls; ++i) {
1252     NamedDecl *D = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1253     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1254     Decls.addDecl(D, AS);
1255   }
1256   E->initializeResults(*Reader.getContext(), Decls.begin(), Decls.end());
1257
1258   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1259   E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1260   E->setQualifierRange(ReadSourceRange(Record, Idx));
1261 }
1262
1263 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1264   VisitOverloadExpr(E);
1265   E->setArrow(Record[Idx++]);
1266   E->setHasUnresolvedUsing(Record[Idx++]);
1267   E->setBase(Reader.ReadSubExpr());
1268   E->setBaseType(Reader.GetType(Record[Idx++]));
1269   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
1270 }
1271
1272 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1273   VisitOverloadExpr(E);
1274   E->setRequiresADL(Record[Idx++]);
1275   E->setOverloaded(Record[Idx++]);
1276   E->setNamingClass(cast_or_null<CXXRecordDecl>(Reader.GetDecl(Record[Idx++])));
1277 }
1278
1279 void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1280   VisitExpr(E);
1281   E->UTT = (UnaryTypeTrait)Record[Idx++];
1282   E->Value = (bool)Record[Idx++];
1283   SourceRange Range = ReadSourceRange(Record, Idx);
1284   E->Loc = Range.getBegin();
1285   E->RParen = Range.getEnd();
1286   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1287 }
1288
1289 void ASTStmtReader::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1290   VisitExpr(E);
1291   E->BTT = (BinaryTypeTrait)Record[Idx++];
1292   E->Value = (bool)Record[Idx++];
1293   SourceRange Range = ReadSourceRange(Record, Idx);
1294   E->Loc = Range.getBegin();
1295   E->RParen = Range.getEnd();
1296   E->LhsType = GetTypeSourceInfo(Record, Idx);
1297   E->RhsType = GetTypeSourceInfo(Record, Idx);
1298 }
1299
1300 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1301   VisitExpr(E);
1302   E->Value = (bool)Record[Idx++];
1303   E->Range = ReadSourceRange(Record, Idx);
1304   E->Operand = Reader.ReadSubExpr();
1305 }
1306
1307 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1308   VisitExpr(E);
1309   E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1310   E->NumExpansions = Record[Idx++];
1311   E->Pattern = Reader.ReadSubExpr();
1312 }
1313
1314 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1315   VisitExpr(E);
1316   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1317   E->PackLoc = ReadSourceLocation(Record, Idx);
1318   E->RParenLoc = ReadSourceLocation(Record, Idx);
1319   E->Length = Record[Idx++];
1320   E->Pack = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1321 }
1322
1323 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1324                                           SubstNonTypeTemplateParmPackExpr *E) {
1325   VisitExpr(E);
1326   E->Param
1327     = cast_or_null<NonTypeTemplateParmDecl>(Reader.GetDecl(Record[Idx++]));
1328   TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);
1329   if (ArgPack.getKind() != TemplateArgument::Pack)
1330     return;
1331
1332   E->Arguments = ArgPack.pack_begin();
1333   E->NumArguments = ArgPack.pack_size();
1334   E->NameLoc = ReadSourceLocation(Record, Idx);
1335 }
1336
1337 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1338   VisitExpr(E);
1339   Idx++; // skip ID
1340   E->Loc = ReadSourceLocation(Record, Idx);
1341 }
1342
1343 //===----------------------------------------------------------------------===//
1344 // CUDA Expressions and Statements
1345 //===----------------------------------------------------------------------===//
1346
1347 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1348   VisitCallExpr(E);
1349   E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));
1350 }
1351
1352 Stmt *ASTReader::ReadStmt(PerFileData &F) {
1353   switch (ReadingKind) {
1354   case Read_Decl:
1355   case Read_Type:
1356     return ReadStmtFromStream(F);
1357   case Read_Stmt:
1358     return ReadSubStmt();
1359   }
1360
1361   llvm_unreachable("ReadingKind not set ?");
1362   return 0;
1363 }
1364
1365 Expr *ASTReader::ReadExpr(PerFileData &F) {
1366   return cast_or_null<Expr>(ReadStmt(F));
1367 }
1368
1369 Expr *ASTReader::ReadSubExpr() {
1370   return cast_or_null<Expr>(ReadSubStmt());
1371 }
1372
1373 // Within the bitstream, expressions are stored in Reverse Polish
1374 // Notation, with each of the subexpressions preceding the
1375 // expression they are stored in. Subexpressions are stored from last to first.
1376 // To evaluate expressions, we continue reading expressions and placing them on
1377 // the stack, with expressions having operands removing those operands from the
1378 // stack. Evaluation terminates when we see a STMT_STOP record, and
1379 // the single remaining expression on the stack is our result.
1380 Stmt *ASTReader::ReadStmtFromStream(PerFileData &F) {
1381
1382   ReadingKindTracker ReadingKind(Read_Stmt, *this);
1383   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
1384
1385 #ifndef NDEBUG
1386   unsigned PrevNumStmts = StmtStack.size();
1387 #endif
1388
1389   RecordData Record;
1390   unsigned Idx;
1391   ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
1392   Stmt::EmptyShell Empty;
1393
1394   while (true) {
1395     unsigned Code = Cursor.ReadCode();
1396     if (Code == llvm::bitc::END_BLOCK) {
1397       if (Cursor.ReadBlockEnd()) {
1398         Error("error at end of block in AST file");
1399         return 0;
1400       }
1401       break;
1402     }
1403
1404     if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1405       // No known subblocks, always skip them.
1406       Cursor.ReadSubBlockID();
1407       if (Cursor.SkipBlock()) {
1408         Error("malformed block record in AST file");
1409         return 0;
1410       }
1411       continue;
1412     }
1413
1414     if (Code == llvm::bitc::DEFINE_ABBREV) {
1415       Cursor.ReadAbbrevRecord();
1416       continue;
1417     }
1418
1419     Stmt *S = 0;
1420     Idx = 0;
1421     Record.clear();
1422     bool Finished = false;
1423     switch ((StmtCode)Cursor.ReadRecord(Code, Record)) {
1424     case STMT_STOP:
1425       Finished = true;
1426       break;
1427
1428     case STMT_NULL_PTR:
1429       S = 0;
1430       break;
1431
1432     case STMT_NULL:
1433       S = new (Context) NullStmt(Empty);
1434       break;
1435
1436     case STMT_COMPOUND:
1437       S = new (Context) CompoundStmt(Empty);
1438       break;
1439
1440     case STMT_CASE:
1441       S = new (Context) CaseStmt(Empty);
1442       break;
1443
1444     case STMT_DEFAULT:
1445       S = new (Context) DefaultStmt(Empty);
1446       break;
1447
1448     case STMT_LABEL:
1449       S = new (Context) LabelStmt(Empty);
1450       break;
1451
1452     case STMT_IF:
1453       S = new (Context) IfStmt(Empty);
1454       break;
1455
1456     case STMT_SWITCH:
1457       S = new (Context) SwitchStmt(Empty);
1458       break;
1459
1460     case STMT_WHILE:
1461       S = new (Context) WhileStmt(Empty);
1462       break;
1463
1464     case STMT_DO:
1465       S = new (Context) DoStmt(Empty);
1466       break;
1467
1468     case STMT_FOR:
1469       S = new (Context) ForStmt(Empty);
1470       break;
1471
1472     case STMT_GOTO:
1473       S = new (Context) GotoStmt(Empty);
1474       break;
1475
1476     case STMT_INDIRECT_GOTO:
1477       S = new (Context) IndirectGotoStmt(Empty);
1478       break;
1479
1480     case STMT_CONTINUE:
1481       S = new (Context) ContinueStmt(Empty);
1482       break;
1483
1484     case STMT_BREAK:
1485       S = new (Context) BreakStmt(Empty);
1486       break;
1487
1488     case STMT_RETURN:
1489       S = new (Context) ReturnStmt(Empty);
1490       break;
1491
1492     case STMT_DECL:
1493       S = new (Context) DeclStmt(Empty);
1494       break;
1495
1496     case STMT_ASM:
1497       S = new (Context) AsmStmt(Empty);
1498       break;
1499
1500     case EXPR_PREDEFINED:
1501       S = new (Context) PredefinedExpr(Empty);
1502       break;
1503
1504     case EXPR_DECL_REF:
1505       S = DeclRefExpr::CreateEmpty(*Context,
1506                          /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
1507           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1],
1508                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1]
1509                                    ? Record[ASTStmtReader::NumExprFields + 2]
1510                                    : 0);
1511       break;
1512
1513     case EXPR_INTEGER_LITERAL:
1514       S = IntegerLiteral::Create(*Context, Empty);
1515       break;
1516
1517     case EXPR_FLOATING_LITERAL:
1518       S = FloatingLiteral::Create(*Context, Empty);
1519       break;
1520
1521     case EXPR_IMAGINARY_LITERAL:
1522       S = new (Context) ImaginaryLiteral(Empty);
1523       break;
1524
1525     case EXPR_STRING_LITERAL:
1526       S = StringLiteral::CreateEmpty(*Context,
1527                                      Record[ASTStmtReader::NumExprFields + 1]);
1528       break;
1529
1530     case EXPR_CHARACTER_LITERAL:
1531       S = new (Context) CharacterLiteral(Empty);
1532       break;
1533
1534     case EXPR_PAREN:
1535       S = new (Context) ParenExpr(Empty);
1536       break;
1537
1538     case EXPR_PAREN_LIST:
1539       S = new (Context) ParenListExpr(Empty);
1540       break;
1541
1542     case EXPR_UNARY_OPERATOR:
1543       S = new (Context) UnaryOperator(Empty);
1544       break;
1545
1546     case EXPR_OFFSETOF:
1547       S = OffsetOfExpr::CreateEmpty(*Context,
1548                                     Record[ASTStmtReader::NumExprFields],
1549                                     Record[ASTStmtReader::NumExprFields + 1]);
1550       break;
1551
1552     case EXPR_SIZEOF_ALIGN_OF:
1553       S = new (Context) SizeOfAlignOfExpr(Empty);
1554       break;
1555
1556     case EXPR_ARRAY_SUBSCRIPT:
1557       S = new (Context) ArraySubscriptExpr(Empty);
1558       break;
1559
1560     case EXPR_CALL:
1561       S = new (Context) CallExpr(*Context, Stmt::CallExprClass, Empty);
1562       break;
1563
1564     case EXPR_MEMBER: {
1565       // We load everything here and fully initialize it at creation.
1566       // That way we can use MemberExpr::Create and don't have to duplicate its
1567       // logic with a MemberExpr::CreateEmpty.
1568
1569       assert(Idx == 0);
1570       NestedNameSpecifier *NNS = 0;
1571       SourceRange QualifierRange;
1572       if (Record[Idx++]) { // HasQualifier.
1573         NNS = ReadNestedNameSpecifier(Record, Idx);
1574         QualifierRange = ReadSourceRange(F, Record, Idx);
1575       }
1576
1577       TemplateArgumentListInfo ArgInfo;
1578       bool HasExplicitTemplateArgs = Record[Idx++];
1579       if (HasExplicitTemplateArgs) {
1580         unsigned NumTemplateArgs = Record[Idx++];
1581         ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
1582         ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
1583         for (unsigned i = 0; i != NumTemplateArgs; ++i)
1584           ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
1585       }
1586
1587       NamedDecl *FoundD = cast_or_null<NamedDecl>(GetDecl(Record[Idx++]));
1588       AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1589       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
1590
1591       QualType T = GetType(Record[Idx++]);
1592       ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
1593       ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
1594       Expr *Base = ReadSubExpr();
1595       ValueDecl *MemberD = cast<ValueDecl>(GetDecl(Record[Idx++]));
1596       SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
1597       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
1598       bool IsArrow = Record[Idx++];
1599
1600       S = MemberExpr::Create(*Context, Base, IsArrow, NNS, QualifierRange,
1601                              MemberD, FoundDecl, MemberNameInfo,
1602                              HasExplicitTemplateArgs ? &ArgInfo : 0, T, VK, OK);
1603       ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
1604                              MemberD->getDeclName(), Record, Idx);
1605       break;
1606     }
1607
1608     case EXPR_BINARY_OPERATOR:
1609       S = new (Context) BinaryOperator(Empty);
1610       break;
1611
1612     case EXPR_COMPOUND_ASSIGN_OPERATOR:
1613       S = new (Context) CompoundAssignOperator(Empty);
1614       break;
1615
1616     case EXPR_CONDITIONAL_OPERATOR:
1617       S = new (Context) ConditionalOperator(Empty);
1618       break;
1619
1620     case EXPR_BINARY_CONDITIONAL_OPERATOR:
1621       S = new (Context) BinaryConditionalOperator(Empty);
1622       break;
1623
1624     case EXPR_IMPLICIT_CAST:
1625       S = ImplicitCastExpr::CreateEmpty(*Context,
1626                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1627       break;
1628
1629     case EXPR_CSTYLE_CAST:
1630       S = CStyleCastExpr::CreateEmpty(*Context,
1631                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1632       break;
1633
1634     case EXPR_COMPOUND_LITERAL:
1635       S = new (Context) CompoundLiteralExpr(Empty);
1636       break;
1637
1638     case EXPR_EXT_VECTOR_ELEMENT:
1639       S = new (Context) ExtVectorElementExpr(Empty);
1640       break;
1641
1642     case EXPR_INIT_LIST:
1643       S = new (Context) InitListExpr(*getContext(), Empty);
1644       break;
1645
1646     case EXPR_DESIGNATED_INIT:
1647       S = DesignatedInitExpr::CreateEmpty(*Context,
1648                                      Record[ASTStmtReader::NumExprFields] - 1);
1649
1650       break;
1651
1652     case EXPR_IMPLICIT_VALUE_INIT:
1653       S = new (Context) ImplicitValueInitExpr(Empty);
1654       break;
1655
1656     case EXPR_VA_ARG:
1657       S = new (Context) VAArgExpr(Empty);
1658       break;
1659
1660     case EXPR_ADDR_LABEL:
1661       S = new (Context) AddrLabelExpr(Empty);
1662       break;
1663
1664     case EXPR_STMT:
1665       S = new (Context) StmtExpr(Empty);
1666       break;
1667
1668     case EXPR_CHOOSE:
1669       S = new (Context) ChooseExpr(Empty);
1670       break;
1671
1672     case EXPR_GNU_NULL:
1673       S = new (Context) GNUNullExpr(Empty);
1674       break;
1675
1676     case EXPR_SHUFFLE_VECTOR:
1677       S = new (Context) ShuffleVectorExpr(Empty);
1678       break;
1679
1680     case EXPR_BLOCK:
1681       S = new (Context) BlockExpr(Empty);
1682       break;
1683
1684     case EXPR_BLOCK_DECL_REF:
1685       S = new (Context) BlockDeclRefExpr(Empty);
1686       break;
1687
1688     case EXPR_OBJC_STRING_LITERAL:
1689       S = new (Context) ObjCStringLiteral(Empty);
1690       break;
1691     case EXPR_OBJC_ENCODE:
1692       S = new (Context) ObjCEncodeExpr(Empty);
1693       break;
1694     case EXPR_OBJC_SELECTOR_EXPR:
1695       S = new (Context) ObjCSelectorExpr(Empty);
1696       break;
1697     case EXPR_OBJC_PROTOCOL_EXPR:
1698       S = new (Context) ObjCProtocolExpr(Empty);
1699       break;
1700     case EXPR_OBJC_IVAR_REF_EXPR:
1701       S = new (Context) ObjCIvarRefExpr(Empty);
1702       break;
1703     case EXPR_OBJC_PROPERTY_REF_EXPR:
1704       S = new (Context) ObjCPropertyRefExpr(Empty);
1705       break;
1706     case EXPR_OBJC_KVC_REF_EXPR:
1707       llvm_unreachable("mismatching AST file");
1708       break;
1709     case EXPR_OBJC_MESSAGE_EXPR:
1710       S = ObjCMessageExpr::CreateEmpty(*Context,
1711                                      Record[ASTStmtReader::NumExprFields]);
1712       break;
1713     case EXPR_OBJC_ISA:
1714       S = new (Context) ObjCIsaExpr(Empty);
1715       break;
1716     case STMT_OBJC_FOR_COLLECTION:
1717       S = new (Context) ObjCForCollectionStmt(Empty);
1718       break;
1719     case STMT_OBJC_CATCH:
1720       S = new (Context) ObjCAtCatchStmt(Empty);
1721       break;
1722     case STMT_OBJC_FINALLY:
1723       S = new (Context) ObjCAtFinallyStmt(Empty);
1724       break;
1725     case STMT_OBJC_AT_TRY:
1726       S = ObjCAtTryStmt::CreateEmpty(*Context,
1727                                      Record[ASTStmtReader::NumStmtFields],
1728                                      Record[ASTStmtReader::NumStmtFields + 1]);
1729       break;
1730     case STMT_OBJC_AT_SYNCHRONIZED:
1731       S = new (Context) ObjCAtSynchronizedStmt(Empty);
1732       break;
1733     case STMT_OBJC_AT_THROW:
1734       S = new (Context) ObjCAtThrowStmt(Empty);
1735       break;
1736
1737     case STMT_CXX_CATCH:
1738       S = new (Context) CXXCatchStmt(Empty);
1739       break;
1740
1741     case STMT_CXX_TRY:
1742       S = CXXTryStmt::Create(*Context, Empty,
1743              /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
1744       break;
1745
1746     case EXPR_CXX_OPERATOR_CALL:
1747       S = new (Context) CXXOperatorCallExpr(*Context, Empty);
1748       break;
1749
1750     case EXPR_CXX_MEMBER_CALL:
1751       S = new (Context) CXXMemberCallExpr(*Context, Empty);
1752       break;
1753
1754     case EXPR_CXX_CONSTRUCT:
1755       S = new (Context) CXXConstructExpr(Empty);
1756       break;
1757
1758     case EXPR_CXX_TEMPORARY_OBJECT:
1759       S = new (Context) CXXTemporaryObjectExpr(Empty);
1760       break;
1761
1762     case EXPR_CXX_STATIC_CAST:
1763       S = CXXStaticCastExpr::CreateEmpty(*Context,
1764                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1765       break;
1766
1767     case EXPR_CXX_DYNAMIC_CAST:
1768       S = CXXDynamicCastExpr::CreateEmpty(*Context,
1769                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1770       break;
1771
1772     case EXPR_CXX_REINTERPRET_CAST:
1773       S = CXXReinterpretCastExpr::CreateEmpty(*Context,
1774                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1775       break;
1776
1777     case EXPR_CXX_CONST_CAST:
1778       S = CXXConstCastExpr::CreateEmpty(*Context);
1779       break;
1780
1781     case EXPR_CXX_FUNCTIONAL_CAST:
1782       S = CXXFunctionalCastExpr::CreateEmpty(*Context,
1783                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1784       break;
1785
1786     case EXPR_CXX_BOOL_LITERAL:
1787       S = new (Context) CXXBoolLiteralExpr(Empty);
1788       break;
1789
1790     case EXPR_CXX_NULL_PTR_LITERAL:
1791       S = new (Context) CXXNullPtrLiteralExpr(Empty);
1792       break;
1793     case EXPR_CXX_TYPEID_EXPR:
1794       S = new (Context) CXXTypeidExpr(Empty, true);
1795       break;
1796     case EXPR_CXX_TYPEID_TYPE:
1797       S = new (Context) CXXTypeidExpr(Empty, false);
1798       break;
1799     case EXPR_CXX_UUIDOF_EXPR:
1800       S = new (Context) CXXUuidofExpr(Empty, true);
1801       break;
1802     case EXPR_CXX_UUIDOF_TYPE:
1803       S = new (Context) CXXUuidofExpr(Empty, false);
1804       break;
1805     case EXPR_CXX_THIS:
1806       S = new (Context) CXXThisExpr(Empty);
1807       break;
1808     case EXPR_CXX_THROW:
1809       S = new (Context) CXXThrowExpr(Empty);
1810       break;
1811     case EXPR_CXX_DEFAULT_ARG: {
1812       bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
1813       if (HasOtherExprStored) {
1814         Expr *SubExpr = ReadSubExpr();
1815         S = CXXDefaultArgExpr::Create(*Context, SourceLocation(), 0, SubExpr);
1816       } else
1817         S = new (Context) CXXDefaultArgExpr(Empty);
1818       break;
1819     }
1820     case EXPR_CXX_BIND_TEMPORARY:
1821       S = new (Context) CXXBindTemporaryExpr(Empty);
1822       break;
1823
1824     case EXPR_CXX_SCALAR_VALUE_INIT:
1825       S = new (Context) CXXScalarValueInitExpr(Empty);
1826       break;
1827     case EXPR_CXX_NEW:
1828       S = new (Context) CXXNewExpr(Empty);
1829       break;
1830     case EXPR_CXX_DELETE:
1831       S = new (Context) CXXDeleteExpr(Empty);
1832       break;
1833     case EXPR_CXX_PSEUDO_DESTRUCTOR:
1834       S = new (Context) CXXPseudoDestructorExpr(Empty);
1835       break;
1836
1837     case EXPR_EXPR_WITH_CLEANUPS:
1838       S = new (Context) ExprWithCleanups(Empty);
1839       break;
1840
1841     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
1842       S = CXXDependentScopeMemberExpr::CreateEmpty(*Context,
1843           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1844                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1845                                    ? Record[ASTStmtReader::NumExprFields + 1]
1846                                    : 0);
1847       break;
1848
1849     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
1850       S = DependentScopeDeclRefExpr::CreateEmpty(*Context,
1851           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1852                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1853                                    ? Record[ASTStmtReader::NumExprFields + 1]
1854                                    : 0);
1855       break;
1856
1857     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
1858       S = CXXUnresolvedConstructExpr::CreateEmpty(*Context,
1859                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
1860       break;
1861
1862     case EXPR_CXX_UNRESOLVED_MEMBER:
1863       S = UnresolvedMemberExpr::CreateEmpty(*Context,
1864           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1865                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1866                                    ? Record[ASTStmtReader::NumExprFields + 1]
1867                                    : 0);
1868       break;
1869
1870     case EXPR_CXX_UNRESOLVED_LOOKUP:
1871       S = UnresolvedLookupExpr::CreateEmpty(*Context,
1872           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1873                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1874                                    ? Record[ASTStmtReader::NumExprFields + 1]
1875                                    : 0);
1876       break;
1877
1878     case EXPR_CXX_UNARY_TYPE_TRAIT:
1879       S = new (Context) UnaryTypeTraitExpr(Empty);
1880       break;
1881
1882     case EXPR_BINARY_TYPE_TRAIT:
1883       S = new (Context) BinaryTypeTraitExpr(Empty);
1884       break;
1885
1886     case EXPR_CXX_NOEXCEPT:
1887       S = new (Context) CXXNoexceptExpr(Empty);
1888       break;
1889
1890     case EXPR_PACK_EXPANSION:
1891       S = new (Context) PackExpansionExpr(Empty);
1892       break;
1893
1894     case EXPR_SIZEOF_PACK:
1895       S = new (Context) SizeOfPackExpr(Empty);
1896       break;
1897
1898     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
1899       S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
1900       break;
1901
1902     case EXPR_OPAQUE_VALUE: {
1903       unsigned key = Record[ASTStmtReader::NumExprFields];
1904       OpaqueValueExpr *&expr = OpaqueValueExprs[key];
1905
1906       // If we already have an entry for this opaque value expression,
1907       // don't bother reading it again.
1908       if (expr) {
1909         StmtStack.push_back(expr);
1910         continue;
1911       }
1912
1913       S = expr = new (Context) OpaqueValueExpr(Empty);
1914       break;
1915     }
1916
1917     case EXPR_CUDA_KERNEL_CALL:
1918       S = new (Context) CUDAKernelCallExpr(*Context, Empty);
1919       break;
1920     }
1921
1922     // We hit a STMT_STOP, so we're done with this expression.
1923     if (Finished)
1924       break;
1925
1926     ++NumStatementsRead;
1927
1928     if (S)
1929       Reader.Visit(S);
1930
1931     assert(Idx == Record.size() && "Invalid deserialization of statement");
1932     StmtStack.push_back(S);
1933   }
1934
1935 #ifndef NDEBUG
1936   assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!");
1937   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
1938 #endif
1939
1940   return StmtStack.pop_back_val();
1941 }