ASTReaderStmt.cpp revision 4045107b7384fd68eed5e3e2f06fc2a47e7be0a6
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 E->IsSuper = Record[Idx++]; 877} 878 879void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { 880 VisitExpr(E); 881 assert(Record[Idx] == E->getNumArgs()); 882 ++Idx; 883 ObjCMessageExpr::ReceiverKind Kind 884 = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]); 885 switch (Kind) { 886 case ObjCMessageExpr::Instance: 887 E->setInstanceReceiver(Reader.ReadSubExpr()); 888 break; 889 890 case ObjCMessageExpr::Class: 891 E->setClassReceiver(GetTypeSourceInfo(Record, Idx)); 892 break; 893 894 case ObjCMessageExpr::SuperClass: 895 case ObjCMessageExpr::SuperInstance: { 896 QualType T = Reader.GetType(Record[Idx++]); 897 SourceLocation SuperLoc = ReadSourceLocation(Record, Idx); 898 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance); 899 break; 900 } 901 } 902 903 assert(Kind == E->getReceiverKind()); 904 905 if (Record[Idx++]) 906 E->setMethodDecl(cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]))); 907 else 908 E->setSelector(Reader.GetSelector(Record, Idx)); 909 910 E->setLeftLoc(ReadSourceLocation(Record, Idx)); 911 E->setRightLoc(ReadSourceLocation(Record, Idx)); 912 913 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 914 E->setArg(I, Reader.ReadSubExpr()); 915} 916 917void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 918 VisitStmt(S); 919 S->setElement(Reader.ReadSubStmt()); 920 S->setCollection(Reader.ReadSubExpr()); 921 S->setBody(Reader.ReadSubStmt()); 922 S->setForLoc(ReadSourceLocation(Record, Idx)); 923 S->setRParenLoc(ReadSourceLocation(Record, Idx)); 924} 925 926void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 927 VisitStmt(S); 928 S->setCatchBody(Reader.ReadSubStmt()); 929 S->setCatchParamDecl(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++]))); 930 S->setAtCatchLoc(ReadSourceLocation(Record, Idx)); 931 S->setRParenLoc(ReadSourceLocation(Record, Idx)); 932} 933 934void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 935 VisitStmt(S); 936 S->setFinallyBody(Reader.ReadSubStmt()); 937 S->setAtFinallyLoc(ReadSourceLocation(Record, Idx)); 938} 939 940void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 941 VisitStmt(S); 942 assert(Record[Idx] == S->getNumCatchStmts()); 943 ++Idx; 944 bool HasFinally = Record[Idx++]; 945 S->setTryBody(Reader.ReadSubStmt()); 946 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) 947 S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt())); 948 949 if (HasFinally) 950 S->setFinallyStmt(Reader.ReadSubStmt()); 951 S->setAtTryLoc(ReadSourceLocation(Record, Idx)); 952} 953 954void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { 955 VisitStmt(S); 956 S->setSynchExpr(Reader.ReadSubStmt()); 957 S->setSynchBody(Reader.ReadSubStmt()); 958 S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx)); 959} 960 961void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 962 VisitStmt(S); 963 S->setThrowExpr(Reader.ReadSubStmt()); 964 S->setThrowLoc(ReadSourceLocation(Record, Idx)); 965} 966 967//===----------------------------------------------------------------------===// 968// C++ Expressions and Statements 969//===----------------------------------------------------------------------===// 970 971void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) { 972 VisitStmt(S); 973 S->CatchLoc = ReadSourceLocation(Record, Idx); 974 S->ExceptionDecl = cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])); 975 S->HandlerBlock = Reader.ReadSubStmt(); 976} 977 978void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) { 979 VisitStmt(S); 980 assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?"); 981 ++Idx; 982 S->TryLoc = ReadSourceLocation(Record, Idx); 983 S->getStmts()[0] = Reader.ReadSubStmt(); 984 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) 985 S->getStmts()[i + 1] = Reader.ReadSubStmt(); 986} 987 988void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 989 VisitCallExpr(E); 990 E->setOperator((OverloadedOperatorKind)Record[Idx++]); 991} 992 993void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { 994 VisitExpr(E); 995 E->NumArgs = Record[Idx++]; 996 if (E->NumArgs) 997 E->Args = new (*Reader.getContext()) Stmt*[E->NumArgs]; 998 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 999 E->setArg(I, Reader.ReadSubExpr()); 1000 E->setConstructor(cast<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++]))); 1001 E->setLocation(ReadSourceLocation(Record, Idx)); 1002 E->setElidable(Record[Idx++]); 1003 E->setRequiresZeroInitialization(Record[Idx++]); 1004 E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]); 1005} 1006 1007void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1008 VisitCXXConstructExpr(E); 1009 E->Type = GetTypeSourceInfo(Record, Idx); 1010 E->RParenLoc = ReadSourceLocation(Record, Idx); 1011} 1012 1013void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 1014 VisitExplicitCastExpr(E); 1015 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 1016} 1017 1018void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { 1019 return VisitCXXNamedCastExpr(E); 1020} 1021 1022void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 1023 return VisitCXXNamedCastExpr(E); 1024} 1025 1026void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { 1027 return VisitCXXNamedCastExpr(E); 1028} 1029 1030void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) { 1031 return VisitCXXNamedCastExpr(E); 1032} 1033 1034void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { 1035 VisitExplicitCastExpr(E); 1036 E->setTypeBeginLoc(ReadSourceLocation(Record, Idx)); 1037 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 1038} 1039 1040void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 1041 VisitExpr(E); 1042 E->setValue(Record[Idx++]); 1043 E->setLocation(ReadSourceLocation(Record, Idx)); 1044} 1045 1046void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 1047 VisitExpr(E); 1048 E->setLocation(ReadSourceLocation(Record, Idx)); 1049} 1050 1051void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 1052 VisitExpr(E); 1053 E->setSourceRange(ReadSourceRange(Record, Idx)); 1054 if (E->isTypeOperand()) { // typeid(int) 1055 E->setTypeOperandSourceInfo( 1056 GetTypeSourceInfo(Record, Idx)); 1057 return; 1058 } 1059 1060 // typeid(42+2) 1061 E->setExprOperand(Reader.ReadSubExpr()); 1062} 1063void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) { 1064 VisitExpr(E); 1065 E->setSourceRange(ReadSourceRange(Record, Idx)); 1066 if (E->isTypeOperand()) { // __uuidof(ComType) 1067 E->setTypeOperandSourceInfo( 1068 GetTypeSourceInfo(Record, Idx)); 1069 return; 1070 } 1071 1072 // __uuidof(expr) 1073 E->setExprOperand(Reader.ReadSubExpr()); 1074} 1075 1076void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) { 1077 VisitExpr(E); 1078 E->setLocation(ReadSourceLocation(Record, Idx)); 1079 E->setImplicit(Record[Idx++]); 1080} 1081 1082void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) { 1083 VisitExpr(E); 1084 E->setThrowLoc(ReadSourceLocation(Record, Idx)); 1085 E->setSubExpr(Reader.ReadSubExpr()); 1086} 1087 1088void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 1089 VisitExpr(E); 1090 1091 assert(Record[Idx] == E->Param.getInt() && "We messed up at creation ?"); 1092 ++Idx; // HasOtherExprStored and SubExpr was handled during creation. 1093 E->Param.setPointer(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++]))); 1094 E->Loc = ReadSourceLocation(Record, Idx); 1095} 1096 1097void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 1098 VisitExpr(E); 1099 E->setTemporary(Reader.ReadCXXTemporary(Record, Idx)); 1100 E->setSubExpr(Reader.ReadSubExpr()); 1101} 1102 1103void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1104 VisitExpr(E); 1105 E->TypeInfo = GetTypeSourceInfo(Record, Idx); 1106 E->RParenLoc = ReadSourceLocation(Record, Idx); 1107} 1108 1109void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { 1110 VisitExpr(E); 1111 E->setGlobalNew(Record[Idx++]); 1112 E->setHasInitializer(Record[Idx++]); 1113 bool isArray = Record[Idx++]; 1114 unsigned NumPlacementArgs = Record[Idx++]; 1115 unsigned NumCtorArgs = Record[Idx++]; 1116 E->setOperatorNew(cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++]))); 1117 E->setOperatorDelete( 1118 cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++]))); 1119 E->setConstructor( 1120 cast_or_null<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++]))); 1121 E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx); 1122 SourceRange TypeIdParens; 1123 TypeIdParens.setBegin(ReadSourceLocation(Record, Idx)); 1124 TypeIdParens.setEnd(ReadSourceLocation(Record, Idx)); 1125 E->TypeIdParens = TypeIdParens; 1126 E->setStartLoc(ReadSourceLocation(Record, Idx)); 1127 E->setEndLoc(ReadSourceLocation(Record, Idx)); 1128 1129 E->AllocateArgsArray(*Reader.getContext(), isArray, NumPlacementArgs, 1130 NumCtorArgs); 1131 1132 // Install all the subexpressions. 1133 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end(); 1134 I != e; ++I) 1135 *I = Reader.ReadSubStmt(); 1136} 1137 1138void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 1139 VisitExpr(E); 1140 E->GlobalDelete = Record[Idx++]; 1141 E->ArrayForm = Record[Idx++]; 1142 E->ArrayFormAsWritten = Record[Idx++]; 1143 E->OperatorDelete = cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])); 1144 E->Argument = Reader.ReadSubExpr(); 1145 E->Loc = ReadSourceLocation(Record, Idx); 1146} 1147 1148void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1149 VisitExpr(E); 1150 1151 E->setBase(Reader.ReadSubExpr()); 1152 E->setArrow(Record[Idx++]); 1153 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 1154 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); 1155 E->setQualifierRange(ReadSourceRange(Record, Idx)); 1156 E->setScopeTypeInfo(GetTypeSourceInfo(Record, Idx)); 1157 E->setColonColonLoc(ReadSourceLocation(Record, Idx)); 1158 E->setTildeLoc(ReadSourceLocation(Record, Idx)); 1159 1160 IdentifierInfo *II = Reader.GetIdentifierInfo(Record, Idx); 1161 if (II) 1162 E->setDestroyedType(II, ReadSourceLocation(Record, Idx)); 1163 else 1164 E->setDestroyedType(GetTypeSourceInfo(Record, Idx)); 1165} 1166 1167void ASTStmtReader::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { 1168 VisitExpr(E); 1169 unsigned NumTemps = Record[Idx++]; 1170 if (NumTemps) { 1171 E->setNumTemporaries(*Reader.getContext(), NumTemps); 1172 for (unsigned i = 0; i != NumTemps; ++i) 1173 E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx)); 1174 } 1175 E->setSubExpr(Reader.ReadSubExpr()); 1176} 1177 1178void 1179ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ 1180 VisitExpr(E); 1181 1182 unsigned NumTemplateArgs = Record[Idx++]; 1183 assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && 1184 "Read wrong record during creation ?"); 1185 if (E->hasExplicitTemplateArgs()) 1186 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), 1187 NumTemplateArgs); 1188 1189 E->setBase(Reader.ReadSubExpr()); 1190 E->setBaseType(Reader.GetType(Record[Idx++])); 1191 E->setArrow(Record[Idx++]); 1192 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 1193 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); 1194 E->setQualifierRange(ReadSourceRange(Record, Idx)); 1195 E->setFirstQualifierFoundInScope( 1196 cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]))); 1197 ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx); 1198} 1199 1200void 1201ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 1202 VisitExpr(E); 1203 1204 unsigned NumTemplateArgs = Record[Idx++]; 1205 assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && 1206 "Read wrong record during creation ?"); 1207 if (E->hasExplicitTemplateArgs()) 1208 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), 1209 NumTemplateArgs); 1210 1211 ReadDeclarationNameInfo(E->NameInfo, Record, Idx); 1212 E->setQualifierRange(ReadSourceRange(Record, Idx)); 1213 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); 1214} 1215 1216void 1217ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { 1218 VisitExpr(E); 1219 assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?"); 1220 ++Idx; // NumArgs; 1221 for (unsigned I = 0, N = E->arg_size(); I != N; ++I) 1222 E->setArg(I, Reader.ReadSubExpr()); 1223 E->Type = GetTypeSourceInfo(Record, Idx); 1224 E->setLParenLoc(ReadSourceLocation(Record, Idx)); 1225 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 1226} 1227 1228void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) { 1229 VisitExpr(E); 1230 1231 unsigned NumTemplateArgs = Record[Idx++]; 1232 assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && 1233 "Read wrong record during creation ?"); 1234 if (E->hasExplicitTemplateArgs()) 1235 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), 1236 NumTemplateArgs); 1237 1238 unsigned NumDecls = Record[Idx++]; 1239 UnresolvedSet<8> Decls; 1240 for (unsigned i = 0; i != NumDecls; ++i) { 1241 NamedDecl *D = cast<NamedDecl>(Reader.GetDecl(Record[Idx++])); 1242 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 1243 Decls.addDecl(D, AS); 1244 } 1245 E->initializeResults(*Reader.getContext(), Decls.begin(), Decls.end()); 1246 1247 ReadDeclarationNameInfo(E->NameInfo, Record, Idx); 1248 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); 1249 E->setQualifierRange(ReadSourceRange(Record, Idx)); 1250} 1251 1252void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 1253 VisitOverloadExpr(E); 1254 E->setArrow(Record[Idx++]); 1255 E->setHasUnresolvedUsing(Record[Idx++]); 1256 E->setBase(Reader.ReadSubExpr()); 1257 E->setBaseType(Reader.GetType(Record[Idx++])); 1258 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 1259} 1260 1261void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 1262 VisitOverloadExpr(E); 1263 E->setRequiresADL(Record[Idx++]); 1264 E->setOverloaded(Record[Idx++]); 1265 E->setNamingClass(cast_or_null<CXXRecordDecl>(Reader.GetDecl(Record[Idx++]))); 1266} 1267 1268void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 1269 VisitExpr(E); 1270 E->UTT = (UnaryTypeTrait)Record[Idx++]; 1271 E->Value = (bool)Record[Idx++]; 1272 SourceRange Range = ReadSourceRange(Record, Idx); 1273 E->Loc = Range.getBegin(); 1274 E->RParen = Range.getEnd(); 1275 E->QueriedType = GetTypeSourceInfo(Record, Idx); 1276} 1277 1278void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 1279 VisitExpr(E); 1280 E->Value = (bool)Record[Idx++]; 1281 E->Range = ReadSourceRange(Record, Idx); 1282 E->Operand = Reader.ReadSubExpr(); 1283} 1284 1285Stmt *ASTReader::ReadStmt(PerFileData &F) { 1286 switch (ReadingKind) { 1287 case Read_Decl: 1288 case Read_Type: 1289 return ReadStmtFromStream(F); 1290 case Read_Stmt: 1291 return ReadSubStmt(); 1292 } 1293 1294 llvm_unreachable("ReadingKind not set ?"); 1295 return 0; 1296} 1297 1298Expr *ASTReader::ReadExpr(PerFileData &F) { 1299 return cast_or_null<Expr>(ReadStmt(F)); 1300} 1301 1302Expr *ASTReader::ReadSubExpr() { 1303 return cast_or_null<Expr>(ReadSubStmt()); 1304} 1305 1306// Within the bitstream, expressions are stored in Reverse Polish 1307// Notation, with each of the subexpressions preceding the 1308// expression they are stored in. Subexpressions are stored from last to first. 1309// To evaluate expressions, we continue reading expressions and placing them on 1310// the stack, with expressions having operands removing those operands from the 1311// stack. Evaluation terminates when we see a STMT_STOP record, and 1312// the single remaining expression on the stack is our result. 1313Stmt *ASTReader::ReadStmtFromStream(PerFileData &F) { 1314 1315 ReadingKindTracker ReadingKind(Read_Stmt, *this); 1316 llvm::BitstreamCursor &Cursor = F.DeclsCursor; 1317 1318#ifndef NDEBUG 1319 unsigned PrevNumStmts = StmtStack.size(); 1320#endif 1321 1322 RecordData Record; 1323 unsigned Idx; 1324 ASTStmtReader Reader(*this, F, Cursor, Record, Idx); 1325 Stmt::EmptyShell Empty; 1326 1327 while (true) { 1328 unsigned Code = Cursor.ReadCode(); 1329 if (Code == llvm::bitc::END_BLOCK) { 1330 if (Cursor.ReadBlockEnd()) { 1331 Error("error at end of block in AST file"); 1332 return 0; 1333 } 1334 break; 1335 } 1336 1337 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1338 // No known subblocks, always skip them. 1339 Cursor.ReadSubBlockID(); 1340 if (Cursor.SkipBlock()) { 1341 Error("malformed block record in AST file"); 1342 return 0; 1343 } 1344 continue; 1345 } 1346 1347 if (Code == llvm::bitc::DEFINE_ABBREV) { 1348 Cursor.ReadAbbrevRecord(); 1349 continue; 1350 } 1351 1352 Stmt *S = 0; 1353 Idx = 0; 1354 Record.clear(); 1355 bool Finished = false; 1356 switch ((StmtCode)Cursor.ReadRecord(Code, Record)) { 1357 case STMT_STOP: 1358 Finished = true; 1359 break; 1360 1361 case STMT_NULL_PTR: 1362 S = 0; 1363 break; 1364 1365 case STMT_NULL: 1366 S = new (Context) NullStmt(Empty); 1367 break; 1368 1369 case STMT_COMPOUND: 1370 S = new (Context) CompoundStmt(Empty); 1371 break; 1372 1373 case STMT_CASE: 1374 S = new (Context) CaseStmt(Empty); 1375 break; 1376 1377 case STMT_DEFAULT: 1378 S = new (Context) DefaultStmt(Empty); 1379 break; 1380 1381 case STMT_LABEL: 1382 S = new (Context) LabelStmt(Empty); 1383 break; 1384 1385 case STMT_IF: 1386 S = new (Context) IfStmt(Empty); 1387 break; 1388 1389 case STMT_SWITCH: 1390 S = new (Context) SwitchStmt(Empty); 1391 break; 1392 1393 case STMT_WHILE: 1394 S = new (Context) WhileStmt(Empty); 1395 break; 1396 1397 case STMT_DO: 1398 S = new (Context) DoStmt(Empty); 1399 break; 1400 1401 case STMT_FOR: 1402 S = new (Context) ForStmt(Empty); 1403 break; 1404 1405 case STMT_GOTO: 1406 S = new (Context) GotoStmt(Empty); 1407 break; 1408 1409 case STMT_INDIRECT_GOTO: 1410 S = new (Context) IndirectGotoStmt(Empty); 1411 break; 1412 1413 case STMT_CONTINUE: 1414 S = new (Context) ContinueStmt(Empty); 1415 break; 1416 1417 case STMT_BREAK: 1418 S = new (Context) BreakStmt(Empty); 1419 break; 1420 1421 case STMT_RETURN: 1422 S = new (Context) ReturnStmt(Empty); 1423 break; 1424 1425 case STMT_DECL: 1426 S = new (Context) DeclStmt(Empty); 1427 break; 1428 1429 case STMT_ASM: 1430 S = new (Context) AsmStmt(Empty); 1431 break; 1432 1433 case EXPR_PREDEFINED: 1434 S = new (Context) PredefinedExpr(Empty); 1435 break; 1436 1437 case EXPR_DECL_REF: 1438 S = DeclRefExpr::CreateEmpty(*Context, 1439 /*HasQualifier=*/Record[ASTStmtReader::NumExprFields], 1440 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1]); 1441 break; 1442 1443 case EXPR_INTEGER_LITERAL: 1444 S = IntegerLiteral::Create(*Context, Empty); 1445 break; 1446 1447 case EXPR_FLOATING_LITERAL: 1448 S = FloatingLiteral::Create(*Context, Empty); 1449 break; 1450 1451 case EXPR_IMAGINARY_LITERAL: 1452 S = new (Context) ImaginaryLiteral(Empty); 1453 break; 1454 1455 case EXPR_STRING_LITERAL: 1456 S = StringLiteral::CreateEmpty(*Context, 1457 Record[ASTStmtReader::NumExprFields + 1]); 1458 break; 1459 1460 case EXPR_CHARACTER_LITERAL: 1461 S = new (Context) CharacterLiteral(Empty); 1462 break; 1463 1464 case EXPR_PAREN: 1465 S = new (Context) ParenExpr(Empty); 1466 break; 1467 1468 case EXPR_PAREN_LIST: 1469 S = new (Context) ParenListExpr(Empty); 1470 break; 1471 1472 case EXPR_UNARY_OPERATOR: 1473 S = new (Context) UnaryOperator(Empty); 1474 break; 1475 1476 case EXPR_OFFSETOF: 1477 S = OffsetOfExpr::CreateEmpty(*Context, 1478 Record[ASTStmtReader::NumExprFields], 1479 Record[ASTStmtReader::NumExprFields + 1]); 1480 break; 1481 1482 case EXPR_SIZEOF_ALIGN_OF: 1483 S = new (Context) SizeOfAlignOfExpr(Empty); 1484 break; 1485 1486 case EXPR_ARRAY_SUBSCRIPT: 1487 S = new (Context) ArraySubscriptExpr(Empty); 1488 break; 1489 1490 case EXPR_CALL: 1491 S = new (Context) CallExpr(*Context, Stmt::CallExprClass, Empty); 1492 break; 1493 1494 case EXPR_MEMBER: { 1495 // We load everything here and fully initialize it at creation. 1496 // That way we can use MemberExpr::Create and don't have to duplicate its 1497 // logic with a MemberExpr::CreateEmpty. 1498 1499 assert(Idx == 0); 1500 NestedNameSpecifier *NNS = 0; 1501 SourceRange QualifierRange; 1502 if (Record[Idx++]) { // HasQualifier. 1503 NNS = ReadNestedNameSpecifier(Record, Idx); 1504 QualifierRange = ReadSourceRange(F, Record, Idx); 1505 } 1506 1507 TemplateArgumentListInfo ArgInfo; 1508 unsigned NumTemplateArgs = Record[Idx++]; 1509 if (NumTemplateArgs) { 1510 ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx)); 1511 ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx)); 1512 for (unsigned i = 0; i != NumTemplateArgs; ++i) 1513 ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx)); 1514 } 1515 1516 NamedDecl *FoundD = cast_or_null<NamedDecl>(GetDecl(Record[Idx++])); 1517 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 1518 DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS); 1519 1520 QualType T = GetType(Record[Idx++]); 1521 Expr *Base = ReadSubExpr(); 1522 ValueDecl *MemberD = cast<ValueDecl>(GetDecl(Record[Idx++])); 1523 SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx); 1524 DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc); 1525 bool IsArrow = Record[Idx++]; 1526 1527 S = MemberExpr::Create(*Context, Base, IsArrow, NNS, QualifierRange, 1528 MemberD, FoundDecl, MemberNameInfo, 1529 NumTemplateArgs ? &ArgInfo : 0, T); 1530 ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc, 1531 MemberD->getDeclName(), Record, Idx); 1532 break; 1533 } 1534 1535 case EXPR_BINARY_OPERATOR: 1536 S = new (Context) BinaryOperator(Empty); 1537 break; 1538 1539 case EXPR_COMPOUND_ASSIGN_OPERATOR: 1540 S = new (Context) CompoundAssignOperator(Empty); 1541 break; 1542 1543 case EXPR_CONDITIONAL_OPERATOR: 1544 S = new (Context) ConditionalOperator(Empty); 1545 break; 1546 1547 case EXPR_IMPLICIT_CAST: 1548 S = ImplicitCastExpr::CreateEmpty(*Context, 1549 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1550 break; 1551 1552 case EXPR_CSTYLE_CAST: 1553 S = CStyleCastExpr::CreateEmpty(*Context, 1554 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1555 break; 1556 1557 case EXPR_COMPOUND_LITERAL: 1558 S = new (Context) CompoundLiteralExpr(Empty); 1559 break; 1560 1561 case EXPR_EXT_VECTOR_ELEMENT: 1562 S = new (Context) ExtVectorElementExpr(Empty); 1563 break; 1564 1565 case EXPR_INIT_LIST: 1566 S = new (Context) InitListExpr(*getContext(), Empty); 1567 break; 1568 1569 case EXPR_DESIGNATED_INIT: 1570 S = DesignatedInitExpr::CreateEmpty(*Context, 1571 Record[ASTStmtReader::NumExprFields] - 1); 1572 1573 break; 1574 1575 case EXPR_IMPLICIT_VALUE_INIT: 1576 S = new (Context) ImplicitValueInitExpr(Empty); 1577 break; 1578 1579 case EXPR_VA_ARG: 1580 S = new (Context) VAArgExpr(Empty); 1581 break; 1582 1583 case EXPR_ADDR_LABEL: 1584 S = new (Context) AddrLabelExpr(Empty); 1585 break; 1586 1587 case EXPR_STMT: 1588 S = new (Context) StmtExpr(Empty); 1589 break; 1590 1591 case EXPR_TYPES_COMPATIBLE: 1592 S = new (Context) TypesCompatibleExpr(Empty); 1593 break; 1594 1595 case EXPR_CHOOSE: 1596 S = new (Context) ChooseExpr(Empty); 1597 break; 1598 1599 case EXPR_GNU_NULL: 1600 S = new (Context) GNUNullExpr(Empty); 1601 break; 1602 1603 case EXPR_SHUFFLE_VECTOR: 1604 S = new (Context) ShuffleVectorExpr(Empty); 1605 break; 1606 1607 case EXPR_BLOCK: 1608 S = new (Context) BlockExpr(Empty); 1609 break; 1610 1611 case EXPR_BLOCK_DECL_REF: 1612 S = new (Context) BlockDeclRefExpr(Empty); 1613 break; 1614 1615 case EXPR_OBJC_STRING_LITERAL: 1616 S = new (Context) ObjCStringLiteral(Empty); 1617 break; 1618 case EXPR_OBJC_ENCODE: 1619 S = new (Context) ObjCEncodeExpr(Empty); 1620 break; 1621 case EXPR_OBJC_SELECTOR_EXPR: 1622 S = new (Context) ObjCSelectorExpr(Empty); 1623 break; 1624 case EXPR_OBJC_PROTOCOL_EXPR: 1625 S = new (Context) ObjCProtocolExpr(Empty); 1626 break; 1627 case EXPR_OBJC_IVAR_REF_EXPR: 1628 S = new (Context) ObjCIvarRefExpr(Empty); 1629 break; 1630 case EXPR_OBJC_PROPERTY_REF_EXPR: 1631 S = new (Context) ObjCPropertyRefExpr(Empty); 1632 break; 1633 case EXPR_OBJC_KVC_REF_EXPR: 1634 S = new (Context) ObjCImplicitSetterGetterRefExpr(Empty); 1635 break; 1636 case EXPR_OBJC_MESSAGE_EXPR: 1637 S = ObjCMessageExpr::CreateEmpty(*Context, 1638 Record[ASTStmtReader::NumExprFields]); 1639 break; 1640 case EXPR_OBJC_ISA: 1641 S = new (Context) ObjCIsaExpr(Empty); 1642 break; 1643 case STMT_OBJC_FOR_COLLECTION: 1644 S = new (Context) ObjCForCollectionStmt(Empty); 1645 break; 1646 case STMT_OBJC_CATCH: 1647 S = new (Context) ObjCAtCatchStmt(Empty); 1648 break; 1649 case STMT_OBJC_FINALLY: 1650 S = new (Context) ObjCAtFinallyStmt(Empty); 1651 break; 1652 case STMT_OBJC_AT_TRY: 1653 S = ObjCAtTryStmt::CreateEmpty(*Context, 1654 Record[ASTStmtReader::NumStmtFields], 1655 Record[ASTStmtReader::NumStmtFields + 1]); 1656 break; 1657 case STMT_OBJC_AT_SYNCHRONIZED: 1658 S = new (Context) ObjCAtSynchronizedStmt(Empty); 1659 break; 1660 case STMT_OBJC_AT_THROW: 1661 S = new (Context) ObjCAtThrowStmt(Empty); 1662 break; 1663 1664 case STMT_CXX_CATCH: 1665 S = new (Context) CXXCatchStmt(Empty); 1666 break; 1667 1668 case STMT_CXX_TRY: 1669 S = CXXTryStmt::Create(*Context, Empty, 1670 /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]); 1671 break; 1672 1673 case EXPR_CXX_OPERATOR_CALL: 1674 S = new (Context) CXXOperatorCallExpr(*Context, Empty); 1675 break; 1676 1677 case EXPR_CXX_MEMBER_CALL: 1678 S = new (Context) CXXMemberCallExpr(*Context, Empty); 1679 break; 1680 1681 case EXPR_CXX_CONSTRUCT: 1682 S = new (Context) CXXConstructExpr(Empty); 1683 break; 1684 1685 case EXPR_CXX_TEMPORARY_OBJECT: 1686 S = new (Context) CXXTemporaryObjectExpr(Empty); 1687 break; 1688 1689 case EXPR_CXX_STATIC_CAST: 1690 S = CXXStaticCastExpr::CreateEmpty(*Context, 1691 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1692 break; 1693 1694 case EXPR_CXX_DYNAMIC_CAST: 1695 S = CXXDynamicCastExpr::CreateEmpty(*Context, 1696 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1697 break; 1698 1699 case EXPR_CXX_REINTERPRET_CAST: 1700 S = CXXReinterpretCastExpr::CreateEmpty(*Context, 1701 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1702 break; 1703 1704 case EXPR_CXX_CONST_CAST: 1705 S = CXXConstCastExpr::CreateEmpty(*Context); 1706 break; 1707 1708 case EXPR_CXX_FUNCTIONAL_CAST: 1709 S = CXXFunctionalCastExpr::CreateEmpty(*Context, 1710 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1711 break; 1712 1713 case EXPR_CXX_BOOL_LITERAL: 1714 S = new (Context) CXXBoolLiteralExpr(Empty); 1715 break; 1716 1717 case EXPR_CXX_NULL_PTR_LITERAL: 1718 S = new (Context) CXXNullPtrLiteralExpr(Empty); 1719 break; 1720 case EXPR_CXX_TYPEID_EXPR: 1721 S = new (Context) CXXTypeidExpr(Empty, true); 1722 break; 1723 case EXPR_CXX_TYPEID_TYPE: 1724 S = new (Context) CXXTypeidExpr(Empty, false); 1725 break; 1726 case EXPR_CXX_UUIDOF_EXPR: 1727 S = new (Context) CXXUuidofExpr(Empty, true); 1728 break; 1729 case EXPR_CXX_UUIDOF_TYPE: 1730 S = new (Context) CXXUuidofExpr(Empty, false); 1731 break; 1732 case EXPR_CXX_THIS: 1733 S = new (Context) CXXThisExpr(Empty); 1734 break; 1735 case EXPR_CXX_THROW: 1736 S = new (Context) CXXThrowExpr(Empty); 1737 break; 1738 case EXPR_CXX_DEFAULT_ARG: { 1739 bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields]; 1740 if (HasOtherExprStored) { 1741 Expr *SubExpr = ReadSubExpr(); 1742 S = CXXDefaultArgExpr::Create(*Context, SourceLocation(), 0, SubExpr); 1743 } else 1744 S = new (Context) CXXDefaultArgExpr(Empty); 1745 break; 1746 } 1747 case EXPR_CXX_BIND_TEMPORARY: 1748 S = new (Context) CXXBindTemporaryExpr(Empty); 1749 break; 1750 1751 case EXPR_CXX_SCALAR_VALUE_INIT: 1752 S = new (Context) CXXScalarValueInitExpr(Empty); 1753 break; 1754 case EXPR_CXX_NEW: 1755 S = new (Context) CXXNewExpr(Empty); 1756 break; 1757 case EXPR_CXX_DELETE: 1758 S = new (Context) CXXDeleteExpr(Empty); 1759 break; 1760 case EXPR_CXX_PSEUDO_DESTRUCTOR: 1761 S = new (Context) CXXPseudoDestructorExpr(Empty); 1762 break; 1763 1764 case EXPR_CXX_EXPR_WITH_TEMPORARIES: 1765 S = new (Context) CXXExprWithTemporaries(Empty); 1766 break; 1767 1768 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: 1769 S = CXXDependentScopeMemberExpr::CreateEmpty(*Context, 1770 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]); 1771 break; 1772 1773 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: 1774 S = DependentScopeDeclRefExpr::CreateEmpty(*Context, 1775 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]); 1776 break; 1777 1778 case EXPR_CXX_UNRESOLVED_CONSTRUCT: 1779 S = CXXUnresolvedConstructExpr::CreateEmpty(*Context, 1780 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]); 1781 break; 1782 1783 case EXPR_CXX_UNRESOLVED_MEMBER: 1784 S = UnresolvedMemberExpr::CreateEmpty(*Context, 1785 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]); 1786 break; 1787 1788 case EXPR_CXX_UNRESOLVED_LOOKUP: 1789 S = UnresolvedLookupExpr::CreateEmpty(*Context, 1790 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]); 1791 break; 1792 1793 case EXPR_CXX_UNARY_TYPE_TRAIT: 1794 S = new (Context) UnaryTypeTraitExpr(Empty); 1795 break; 1796 1797 case EXPR_CXX_NOEXCEPT: 1798 S = new (Context) CXXNoexceptExpr(Empty); 1799 break; 1800 } 1801 1802 // We hit a STMT_STOP, so we're done with this expression. 1803 if (Finished) 1804 break; 1805 1806 ++NumStatementsRead; 1807 1808 if (S) 1809 Reader.Visit(S); 1810 1811 assert(Idx == Record.size() && "Invalid deserialization of statement"); 1812 StmtStack.push_back(S); 1813 } 1814 1815#ifndef NDEBUG 1816 assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!"); 1817 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"); 1818#endif 1819 1820 return StmtStack.pop_back_val(); 1821} 1822