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