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