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