ASTReaderStmt.cpp revision 428edafa9eb80e01dd40aab31d4166a787a741e1
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 E->ParenRange = ReadSourceRange(Record, Idx); 1005} 1006 1007void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1008 VisitCXXConstructExpr(E); 1009 E->Type = GetTypeSourceInfo(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->StartLoc = ReadSourceLocation(Record, Idx); 1126 E->EndLoc = ReadSourceLocation(Record, Idx); 1127 E->ConstructorLParen = ReadSourceLocation(Record, Idx); 1128 E->ConstructorRParen = ReadSourceLocation(Record, Idx); 1129 1130 E->AllocateArgsArray(*Reader.getContext(), isArray, NumPlacementArgs, 1131 NumCtorArgs); 1132 1133 // Install all the subexpressions. 1134 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end(); 1135 I != e; ++I) 1136 *I = Reader.ReadSubStmt(); 1137} 1138 1139void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 1140 VisitExpr(E); 1141 E->GlobalDelete = Record[Idx++]; 1142 E->ArrayForm = Record[Idx++]; 1143 E->ArrayFormAsWritten = Record[Idx++]; 1144 E->OperatorDelete = cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])); 1145 E->Argument = Reader.ReadSubExpr(); 1146 E->Loc = ReadSourceLocation(Record, Idx); 1147} 1148 1149void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1150 VisitExpr(E); 1151 1152 E->setBase(Reader.ReadSubExpr()); 1153 E->setArrow(Record[Idx++]); 1154 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 1155 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); 1156 E->setQualifierRange(ReadSourceRange(Record, Idx)); 1157 E->setScopeTypeInfo(GetTypeSourceInfo(Record, Idx)); 1158 E->setColonColonLoc(ReadSourceLocation(Record, Idx)); 1159 E->setTildeLoc(ReadSourceLocation(Record, Idx)); 1160 1161 IdentifierInfo *II = Reader.GetIdentifierInfo(Record, Idx); 1162 if (II) 1163 E->setDestroyedType(II, ReadSourceLocation(Record, Idx)); 1164 else 1165 E->setDestroyedType(GetTypeSourceInfo(Record, Idx)); 1166} 1167 1168void ASTStmtReader::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { 1169 VisitExpr(E); 1170 unsigned NumTemps = Record[Idx++]; 1171 if (NumTemps) { 1172 E->setNumTemporaries(*Reader.getContext(), NumTemps); 1173 for (unsigned i = 0; i != NumTemps; ++i) 1174 E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx)); 1175 } 1176 E->setSubExpr(Reader.ReadSubExpr()); 1177} 1178 1179void 1180ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ 1181 VisitExpr(E); 1182 1183 unsigned NumTemplateArgs = Record[Idx++]; 1184 assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && 1185 "Read wrong record during creation ?"); 1186 if (E->hasExplicitTemplateArgs()) 1187 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), 1188 NumTemplateArgs); 1189 1190 E->setBase(Reader.ReadSubExpr()); 1191 E->setBaseType(Reader.GetType(Record[Idx++])); 1192 E->setArrow(Record[Idx++]); 1193 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 1194 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); 1195 E->setQualifierRange(ReadSourceRange(Record, Idx)); 1196 E->setFirstQualifierFoundInScope( 1197 cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]))); 1198 ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx); 1199} 1200 1201void 1202ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 1203 VisitExpr(E); 1204 1205 unsigned NumTemplateArgs = Record[Idx++]; 1206 assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && 1207 "Read wrong record during creation ?"); 1208 if (E->hasExplicitTemplateArgs()) 1209 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), 1210 NumTemplateArgs); 1211 1212 ReadDeclarationNameInfo(E->NameInfo, Record, Idx); 1213 E->setQualifierRange(ReadSourceRange(Record, Idx)); 1214 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); 1215} 1216 1217void 1218ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { 1219 VisitExpr(E); 1220 assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?"); 1221 ++Idx; // NumArgs; 1222 for (unsigned I = 0, N = E->arg_size(); I != N; ++I) 1223 E->setArg(I, Reader.ReadSubExpr()); 1224 E->Type = GetTypeSourceInfo(Record, Idx); 1225 E->setLParenLoc(ReadSourceLocation(Record, Idx)); 1226 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 1227} 1228 1229void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) { 1230 VisitExpr(E); 1231 1232 unsigned NumTemplateArgs = Record[Idx++]; 1233 assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && 1234 "Read wrong record during creation ?"); 1235 if (E->hasExplicitTemplateArgs()) 1236 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), 1237 NumTemplateArgs); 1238 1239 unsigned NumDecls = Record[Idx++]; 1240 UnresolvedSet<8> Decls; 1241 for (unsigned i = 0; i != NumDecls; ++i) { 1242 NamedDecl *D = cast<NamedDecl>(Reader.GetDecl(Record[Idx++])); 1243 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 1244 Decls.addDecl(D, AS); 1245 } 1246 E->initializeResults(*Reader.getContext(), Decls.begin(), Decls.end()); 1247 1248 ReadDeclarationNameInfo(E->NameInfo, Record, Idx); 1249 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); 1250 E->setQualifierRange(ReadSourceRange(Record, Idx)); 1251} 1252 1253void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 1254 VisitOverloadExpr(E); 1255 E->setArrow(Record[Idx++]); 1256 E->setHasUnresolvedUsing(Record[Idx++]); 1257 E->setBase(Reader.ReadSubExpr()); 1258 E->setBaseType(Reader.GetType(Record[Idx++])); 1259 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 1260} 1261 1262void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 1263 VisitOverloadExpr(E); 1264 E->setRequiresADL(Record[Idx++]); 1265 E->setOverloaded(Record[Idx++]); 1266 E->setNamingClass(cast_or_null<CXXRecordDecl>(Reader.GetDecl(Record[Idx++]))); 1267} 1268 1269void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 1270 VisitExpr(E); 1271 E->UTT = (UnaryTypeTrait)Record[Idx++]; 1272 E->Value = (bool)Record[Idx++]; 1273 SourceRange Range = ReadSourceRange(Record, Idx); 1274 E->Loc = Range.getBegin(); 1275 E->RParen = Range.getEnd(); 1276 E->QueriedType = GetTypeSourceInfo(Record, Idx); 1277} 1278 1279void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 1280 VisitExpr(E); 1281 E->Value = (bool)Record[Idx++]; 1282 E->Range = ReadSourceRange(Record, Idx); 1283 E->Operand = Reader.ReadSubExpr(); 1284} 1285 1286Stmt *ASTReader::ReadStmt(PerFileData &F) { 1287 switch (ReadingKind) { 1288 case Read_Decl: 1289 case Read_Type: 1290 return ReadStmtFromStream(F); 1291 case Read_Stmt: 1292 return ReadSubStmt(); 1293 } 1294 1295 llvm_unreachable("ReadingKind not set ?"); 1296 return 0; 1297} 1298 1299Expr *ASTReader::ReadExpr(PerFileData &F) { 1300 return cast_or_null<Expr>(ReadStmt(F)); 1301} 1302 1303Expr *ASTReader::ReadSubExpr() { 1304 return cast_or_null<Expr>(ReadSubStmt()); 1305} 1306 1307// Within the bitstream, expressions are stored in Reverse Polish 1308// Notation, with each of the subexpressions preceding the 1309// expression they are stored in. Subexpressions are stored from last to first. 1310// To evaluate expressions, we continue reading expressions and placing them on 1311// the stack, with expressions having operands removing those operands from the 1312// stack. Evaluation terminates when we see a STMT_STOP record, and 1313// the single remaining expression on the stack is our result. 1314Stmt *ASTReader::ReadStmtFromStream(PerFileData &F) { 1315 1316 ReadingKindTracker ReadingKind(Read_Stmt, *this); 1317 llvm::BitstreamCursor &Cursor = F.DeclsCursor; 1318 1319#ifndef NDEBUG 1320 unsigned PrevNumStmts = StmtStack.size(); 1321#endif 1322 1323 RecordData Record; 1324 unsigned Idx; 1325 ASTStmtReader Reader(*this, F, Cursor, Record, Idx); 1326 Stmt::EmptyShell Empty; 1327 1328 while (true) { 1329 unsigned Code = Cursor.ReadCode(); 1330 if (Code == llvm::bitc::END_BLOCK) { 1331 if (Cursor.ReadBlockEnd()) { 1332 Error("error at end of block in AST file"); 1333 return 0; 1334 } 1335 break; 1336 } 1337 1338 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1339 // No known subblocks, always skip them. 1340 Cursor.ReadSubBlockID(); 1341 if (Cursor.SkipBlock()) { 1342 Error("malformed block record in AST file"); 1343 return 0; 1344 } 1345 continue; 1346 } 1347 1348 if (Code == llvm::bitc::DEFINE_ABBREV) { 1349 Cursor.ReadAbbrevRecord(); 1350 continue; 1351 } 1352 1353 Stmt *S = 0; 1354 Idx = 0; 1355 Record.clear(); 1356 bool Finished = false; 1357 switch ((StmtCode)Cursor.ReadRecord(Code, Record)) { 1358 case STMT_STOP: 1359 Finished = true; 1360 break; 1361 1362 case STMT_NULL_PTR: 1363 S = 0; 1364 break; 1365 1366 case STMT_NULL: 1367 S = new (Context) NullStmt(Empty); 1368 break; 1369 1370 case STMT_COMPOUND: 1371 S = new (Context) CompoundStmt(Empty); 1372 break; 1373 1374 case STMT_CASE: 1375 S = new (Context) CaseStmt(Empty); 1376 break; 1377 1378 case STMT_DEFAULT: 1379 S = new (Context) DefaultStmt(Empty); 1380 break; 1381 1382 case STMT_LABEL: 1383 S = new (Context) LabelStmt(Empty); 1384 break; 1385 1386 case STMT_IF: 1387 S = new (Context) IfStmt(Empty); 1388 break; 1389 1390 case STMT_SWITCH: 1391 S = new (Context) SwitchStmt(Empty); 1392 break; 1393 1394 case STMT_WHILE: 1395 S = new (Context) WhileStmt(Empty); 1396 break; 1397 1398 case STMT_DO: 1399 S = new (Context) DoStmt(Empty); 1400 break; 1401 1402 case STMT_FOR: 1403 S = new (Context) ForStmt(Empty); 1404 break; 1405 1406 case STMT_GOTO: 1407 S = new (Context) GotoStmt(Empty); 1408 break; 1409 1410 case STMT_INDIRECT_GOTO: 1411 S = new (Context) IndirectGotoStmt(Empty); 1412 break; 1413 1414 case STMT_CONTINUE: 1415 S = new (Context) ContinueStmt(Empty); 1416 break; 1417 1418 case STMT_BREAK: 1419 S = new (Context) BreakStmt(Empty); 1420 break; 1421 1422 case STMT_RETURN: 1423 S = new (Context) ReturnStmt(Empty); 1424 break; 1425 1426 case STMT_DECL: 1427 S = new (Context) DeclStmt(Empty); 1428 break; 1429 1430 case STMT_ASM: 1431 S = new (Context) AsmStmt(Empty); 1432 break; 1433 1434 case EXPR_PREDEFINED: 1435 S = new (Context) PredefinedExpr(Empty); 1436 break; 1437 1438 case EXPR_DECL_REF: 1439 S = DeclRefExpr::CreateEmpty(*Context, 1440 /*HasQualifier=*/Record[ASTStmtReader::NumExprFields], 1441 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1]); 1442 break; 1443 1444 case EXPR_INTEGER_LITERAL: 1445 S = IntegerLiteral::Create(*Context, Empty); 1446 break; 1447 1448 case EXPR_FLOATING_LITERAL: 1449 S = FloatingLiteral::Create(*Context, Empty); 1450 break; 1451 1452 case EXPR_IMAGINARY_LITERAL: 1453 S = new (Context) ImaginaryLiteral(Empty); 1454 break; 1455 1456 case EXPR_STRING_LITERAL: 1457 S = StringLiteral::CreateEmpty(*Context, 1458 Record[ASTStmtReader::NumExprFields + 1]); 1459 break; 1460 1461 case EXPR_CHARACTER_LITERAL: 1462 S = new (Context) CharacterLiteral(Empty); 1463 break; 1464 1465 case EXPR_PAREN: 1466 S = new (Context) ParenExpr(Empty); 1467 break; 1468 1469 case EXPR_PAREN_LIST: 1470 S = new (Context) ParenListExpr(Empty); 1471 break; 1472 1473 case EXPR_UNARY_OPERATOR: 1474 S = new (Context) UnaryOperator(Empty); 1475 break; 1476 1477 case EXPR_OFFSETOF: 1478 S = OffsetOfExpr::CreateEmpty(*Context, 1479 Record[ASTStmtReader::NumExprFields], 1480 Record[ASTStmtReader::NumExprFields + 1]); 1481 break; 1482 1483 case EXPR_SIZEOF_ALIGN_OF: 1484 S = new (Context) SizeOfAlignOfExpr(Empty); 1485 break; 1486 1487 case EXPR_ARRAY_SUBSCRIPT: 1488 S = new (Context) ArraySubscriptExpr(Empty); 1489 break; 1490 1491 case EXPR_CALL: 1492 S = new (Context) CallExpr(*Context, Stmt::CallExprClass, Empty); 1493 break; 1494 1495 case EXPR_MEMBER: { 1496 // We load everything here and fully initialize it at creation. 1497 // That way we can use MemberExpr::Create and don't have to duplicate its 1498 // logic with a MemberExpr::CreateEmpty. 1499 1500 assert(Idx == 0); 1501 NestedNameSpecifier *NNS = 0; 1502 SourceRange QualifierRange; 1503 if (Record[Idx++]) { // HasQualifier. 1504 NNS = ReadNestedNameSpecifier(Record, Idx); 1505 QualifierRange = ReadSourceRange(F, Record, Idx); 1506 } 1507 1508 TemplateArgumentListInfo ArgInfo; 1509 unsigned NumTemplateArgs = Record[Idx++]; 1510 if (NumTemplateArgs) { 1511 ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx)); 1512 ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx)); 1513 for (unsigned i = 0; i != NumTemplateArgs; ++i) 1514 ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx)); 1515 } 1516 1517 NamedDecl *FoundD = cast_or_null<NamedDecl>(GetDecl(Record[Idx++])); 1518 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 1519 DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS); 1520 1521 QualType T = GetType(Record[Idx++]); 1522 Expr *Base = ReadSubExpr(); 1523 ValueDecl *MemberD = cast<ValueDecl>(GetDecl(Record[Idx++])); 1524 SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx); 1525 DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc); 1526 bool IsArrow = Record[Idx++]; 1527 1528 S = MemberExpr::Create(*Context, Base, IsArrow, NNS, QualifierRange, 1529 MemberD, FoundDecl, MemberNameInfo, 1530 NumTemplateArgs ? &ArgInfo : 0, T); 1531 ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc, 1532 MemberD->getDeclName(), Record, Idx); 1533 break; 1534 } 1535 1536 case EXPR_BINARY_OPERATOR: 1537 S = new (Context) BinaryOperator(Empty); 1538 break; 1539 1540 case EXPR_COMPOUND_ASSIGN_OPERATOR: 1541 S = new (Context) CompoundAssignOperator(Empty); 1542 break; 1543 1544 case EXPR_CONDITIONAL_OPERATOR: 1545 S = new (Context) ConditionalOperator(Empty); 1546 break; 1547 1548 case EXPR_IMPLICIT_CAST: 1549 S = ImplicitCastExpr::CreateEmpty(*Context, 1550 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1551 break; 1552 1553 case EXPR_CSTYLE_CAST: 1554 S = CStyleCastExpr::CreateEmpty(*Context, 1555 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1556 break; 1557 1558 case EXPR_COMPOUND_LITERAL: 1559 S = new (Context) CompoundLiteralExpr(Empty); 1560 break; 1561 1562 case EXPR_EXT_VECTOR_ELEMENT: 1563 S = new (Context) ExtVectorElementExpr(Empty); 1564 break; 1565 1566 case EXPR_INIT_LIST: 1567 S = new (Context) InitListExpr(*getContext(), Empty); 1568 break; 1569 1570 case EXPR_DESIGNATED_INIT: 1571 S = DesignatedInitExpr::CreateEmpty(*Context, 1572 Record[ASTStmtReader::NumExprFields] - 1); 1573 1574 break; 1575 1576 case EXPR_IMPLICIT_VALUE_INIT: 1577 S = new (Context) ImplicitValueInitExpr(Empty); 1578 break; 1579 1580 case EXPR_VA_ARG: 1581 S = new (Context) VAArgExpr(Empty); 1582 break; 1583 1584 case EXPR_ADDR_LABEL: 1585 S = new (Context) AddrLabelExpr(Empty); 1586 break; 1587 1588 case EXPR_STMT: 1589 S = new (Context) StmtExpr(Empty); 1590 break; 1591 1592 case EXPR_TYPES_COMPATIBLE: 1593 S = new (Context) TypesCompatibleExpr(Empty); 1594 break; 1595 1596 case EXPR_CHOOSE: 1597 S = new (Context) ChooseExpr(Empty); 1598 break; 1599 1600 case EXPR_GNU_NULL: 1601 S = new (Context) GNUNullExpr(Empty); 1602 break; 1603 1604 case EXPR_SHUFFLE_VECTOR: 1605 S = new (Context) ShuffleVectorExpr(Empty); 1606 break; 1607 1608 case EXPR_BLOCK: 1609 S = new (Context) BlockExpr(Empty); 1610 break; 1611 1612 case EXPR_BLOCK_DECL_REF: 1613 S = new (Context) BlockDeclRefExpr(Empty); 1614 break; 1615 1616 case EXPR_OBJC_STRING_LITERAL: 1617 S = new (Context) ObjCStringLiteral(Empty); 1618 break; 1619 case EXPR_OBJC_ENCODE: 1620 S = new (Context) ObjCEncodeExpr(Empty); 1621 break; 1622 case EXPR_OBJC_SELECTOR_EXPR: 1623 S = new (Context) ObjCSelectorExpr(Empty); 1624 break; 1625 case EXPR_OBJC_PROTOCOL_EXPR: 1626 S = new (Context) ObjCProtocolExpr(Empty); 1627 break; 1628 case EXPR_OBJC_IVAR_REF_EXPR: 1629 S = new (Context) ObjCIvarRefExpr(Empty); 1630 break; 1631 case EXPR_OBJC_PROPERTY_REF_EXPR: 1632 S = new (Context) ObjCPropertyRefExpr(Empty); 1633 break; 1634 case EXPR_OBJC_KVC_REF_EXPR: 1635 S = new (Context) ObjCImplicitSetterGetterRefExpr(Empty); 1636 break; 1637 case EXPR_OBJC_MESSAGE_EXPR: 1638 S = ObjCMessageExpr::CreateEmpty(*Context, 1639 Record[ASTStmtReader::NumExprFields]); 1640 break; 1641 case EXPR_OBJC_ISA: 1642 S = new (Context) ObjCIsaExpr(Empty); 1643 break; 1644 case STMT_OBJC_FOR_COLLECTION: 1645 S = new (Context) ObjCForCollectionStmt(Empty); 1646 break; 1647 case STMT_OBJC_CATCH: 1648 S = new (Context) ObjCAtCatchStmt(Empty); 1649 break; 1650 case STMT_OBJC_FINALLY: 1651 S = new (Context) ObjCAtFinallyStmt(Empty); 1652 break; 1653 case STMT_OBJC_AT_TRY: 1654 S = ObjCAtTryStmt::CreateEmpty(*Context, 1655 Record[ASTStmtReader::NumStmtFields], 1656 Record[ASTStmtReader::NumStmtFields + 1]); 1657 break; 1658 case STMT_OBJC_AT_SYNCHRONIZED: 1659 S = new (Context) ObjCAtSynchronizedStmt(Empty); 1660 break; 1661 case STMT_OBJC_AT_THROW: 1662 S = new (Context) ObjCAtThrowStmt(Empty); 1663 break; 1664 1665 case STMT_CXX_CATCH: 1666 S = new (Context) CXXCatchStmt(Empty); 1667 break; 1668 1669 case STMT_CXX_TRY: 1670 S = CXXTryStmt::Create(*Context, Empty, 1671 /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]); 1672 break; 1673 1674 case EXPR_CXX_OPERATOR_CALL: 1675 S = new (Context) CXXOperatorCallExpr(*Context, Empty); 1676 break; 1677 1678 case EXPR_CXX_MEMBER_CALL: 1679 S = new (Context) CXXMemberCallExpr(*Context, Empty); 1680 break; 1681 1682 case EXPR_CXX_CONSTRUCT: 1683 S = new (Context) CXXConstructExpr(Empty); 1684 break; 1685 1686 case EXPR_CXX_TEMPORARY_OBJECT: 1687 S = new (Context) CXXTemporaryObjectExpr(Empty); 1688 break; 1689 1690 case EXPR_CXX_STATIC_CAST: 1691 S = CXXStaticCastExpr::CreateEmpty(*Context, 1692 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1693 break; 1694 1695 case EXPR_CXX_DYNAMIC_CAST: 1696 S = CXXDynamicCastExpr::CreateEmpty(*Context, 1697 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1698 break; 1699 1700 case EXPR_CXX_REINTERPRET_CAST: 1701 S = CXXReinterpretCastExpr::CreateEmpty(*Context, 1702 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1703 break; 1704 1705 case EXPR_CXX_CONST_CAST: 1706 S = CXXConstCastExpr::CreateEmpty(*Context); 1707 break; 1708 1709 case EXPR_CXX_FUNCTIONAL_CAST: 1710 S = CXXFunctionalCastExpr::CreateEmpty(*Context, 1711 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1712 break; 1713 1714 case EXPR_CXX_BOOL_LITERAL: 1715 S = new (Context) CXXBoolLiteralExpr(Empty); 1716 break; 1717 1718 case EXPR_CXX_NULL_PTR_LITERAL: 1719 S = new (Context) CXXNullPtrLiteralExpr(Empty); 1720 break; 1721 case EXPR_CXX_TYPEID_EXPR: 1722 S = new (Context) CXXTypeidExpr(Empty, true); 1723 break; 1724 case EXPR_CXX_TYPEID_TYPE: 1725 S = new (Context) CXXTypeidExpr(Empty, false); 1726 break; 1727 case EXPR_CXX_UUIDOF_EXPR: 1728 S = new (Context) CXXUuidofExpr(Empty, true); 1729 break; 1730 case EXPR_CXX_UUIDOF_TYPE: 1731 S = new (Context) CXXUuidofExpr(Empty, false); 1732 break; 1733 case EXPR_CXX_THIS: 1734 S = new (Context) CXXThisExpr(Empty); 1735 break; 1736 case EXPR_CXX_THROW: 1737 S = new (Context) CXXThrowExpr(Empty); 1738 break; 1739 case EXPR_CXX_DEFAULT_ARG: { 1740 bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields]; 1741 if (HasOtherExprStored) { 1742 Expr *SubExpr = ReadSubExpr(); 1743 S = CXXDefaultArgExpr::Create(*Context, SourceLocation(), 0, SubExpr); 1744 } else 1745 S = new (Context) CXXDefaultArgExpr(Empty); 1746 break; 1747 } 1748 case EXPR_CXX_BIND_TEMPORARY: 1749 S = new (Context) CXXBindTemporaryExpr(Empty); 1750 break; 1751 1752 case EXPR_CXX_SCALAR_VALUE_INIT: 1753 S = new (Context) CXXScalarValueInitExpr(Empty); 1754 break; 1755 case EXPR_CXX_NEW: 1756 S = new (Context) CXXNewExpr(Empty); 1757 break; 1758 case EXPR_CXX_DELETE: 1759 S = new (Context) CXXDeleteExpr(Empty); 1760 break; 1761 case EXPR_CXX_PSEUDO_DESTRUCTOR: 1762 S = new (Context) CXXPseudoDestructorExpr(Empty); 1763 break; 1764 1765 case EXPR_CXX_EXPR_WITH_TEMPORARIES: 1766 S = new (Context) CXXExprWithTemporaries(Empty); 1767 break; 1768 1769 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: 1770 S = CXXDependentScopeMemberExpr::CreateEmpty(*Context, 1771 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]); 1772 break; 1773 1774 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: 1775 S = DependentScopeDeclRefExpr::CreateEmpty(*Context, 1776 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]); 1777 break; 1778 1779 case EXPR_CXX_UNRESOLVED_CONSTRUCT: 1780 S = CXXUnresolvedConstructExpr::CreateEmpty(*Context, 1781 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]); 1782 break; 1783 1784 case EXPR_CXX_UNRESOLVED_MEMBER: 1785 S = UnresolvedMemberExpr::CreateEmpty(*Context, 1786 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]); 1787 break; 1788 1789 case EXPR_CXX_UNRESOLVED_LOOKUP: 1790 S = UnresolvedLookupExpr::CreateEmpty(*Context, 1791 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]); 1792 break; 1793 1794 case EXPR_CXX_UNARY_TYPE_TRAIT: 1795 S = new (Context) UnaryTypeTraitExpr(Empty); 1796 break; 1797 1798 case EXPR_CXX_NOEXCEPT: 1799 S = new (Context) CXXNoexceptExpr(Empty); 1800 break; 1801 } 1802 1803 // We hit a STMT_STOP, so we're done with this expression. 1804 if (Finished) 1805 break; 1806 1807 ++NumStatementsRead; 1808 1809 if (S) 1810 Reader.Visit(S); 1811 1812 assert(Idx == Record.size() && "Invalid deserialization of statement"); 1813 StmtStack.push_back(S); 1814 } 1815 1816#ifndef NDEBUG 1817 assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!"); 1818 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"); 1819#endif 1820 1821 return StmtStack.pop_back_val(); 1822} 1823