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/DeclTemplate.h" 18 #include "clang/AST/StmtVisitor.h" 19 #include "llvm/ADT/SmallString.h" 20 using namespace clang; 21 using namespace clang::serialization; 22 23 namespace clang { 24 25 class ASTStmtReader : public StmtVisitor<ASTStmtReader> { 26 typedef ASTReader::RecordData RecordData; 27 28 ASTReader &Reader; 29 ModuleFile &F; 30 llvm::BitstreamCursor &DeclsCursor; 31 const ASTReader::RecordData &Record; 32 unsigned &Idx; 33 34 SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) { 35 return Reader.ReadSourceLocation(F, R, I); 36 } 37 38 SourceRange ReadSourceRange(const RecordData &R, unsigned &I) { 39 return Reader.ReadSourceRange(F, R, I); 40 } 41 42 TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) { 43 return Reader.GetTypeSourceInfo(F, R, I); 44 } 45 46 serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) { 47 return Reader.ReadDeclID(F, R, I); 48 } 49 50 Decl *ReadDecl(const RecordData &R, unsigned &I) { 51 return Reader.ReadDecl(F, R, I); 52 } 53 54 template<typename T> 55 T *ReadDeclAs(const RecordData &R, unsigned &I) { 56 return Reader.ReadDeclAs<T>(F, R, I); 57 } 58 59 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name, 60 const ASTReader::RecordData &R, unsigned &I) { 61 Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I); 62 } 63 64 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo, 65 const ASTReader::RecordData &R, unsigned &I) { 66 Reader.ReadDeclarationNameInfo(F, NameInfo, R, I); 67 } 68 69 public: 70 ASTStmtReader(ASTReader &Reader, ModuleFile &F, 71 llvm::BitstreamCursor &Cursor, 72 const ASTReader::RecordData &Record, unsigned &Idx) 73 : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { } 74 75 /// \brief The number of record fields required for the Stmt class 76 /// itself. 77 static const unsigned NumStmtFields = 0; 78 79 /// \brief The number of record fields required for the Expr class 80 /// itself. 81 static const unsigned NumExprFields = NumStmtFields + 7; 82 83 /// \brief Read and initialize a ExplicitTemplateArgumentList structure. 84 void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, 85 unsigned NumTemplateArgs); 86 /// \brief Read and initialize a ExplicitTemplateArgumentList structure. 87 void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList, 88 unsigned NumTemplateArgs); 89 90 void VisitStmt(Stmt *S); 91 #define STMT(Type, Base) \ 92 void Visit##Type(Type *); 93 #include "clang/AST/StmtNodes.inc" 94 }; 95 } 96 97 void ASTStmtReader:: 98 ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, 99 unsigned NumTemplateArgs) { 100 SourceLocation TemplateKWLoc = ReadSourceLocation(Record, Idx); 101 TemplateArgumentListInfo ArgInfo; 102 ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx)); 103 ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx)); 104 for (unsigned i = 0; i != NumTemplateArgs; ++i) 105 ArgInfo.addArgument( 106 Reader.ReadTemplateArgumentLoc(F, Record, Idx)); 107 Args.initializeFrom(TemplateKWLoc, ArgInfo); 108 } 109 110 void ASTStmtReader::VisitStmt(Stmt *S) { 111 assert(Idx == NumStmtFields && "Incorrect statement field count"); 112 } 113 114 void ASTStmtReader::VisitNullStmt(NullStmt *S) { 115 VisitStmt(S); 116 S->setSemiLoc(ReadSourceLocation(Record, Idx)); 117 S->HasLeadingEmptyMacro = Record[Idx++]; 118 } 119 120 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) { 121 VisitStmt(S); 122 SmallVector<Stmt *, 16> Stmts; 123 unsigned NumStmts = Record[Idx++]; 124 while (NumStmts--) 125 Stmts.push_back(Reader.ReadSubStmt()); 126 S->setStmts(Reader.getContext(), Stmts.data(), Stmts.size()); 127 S->setLBracLoc(ReadSourceLocation(Record, Idx)); 128 S->setRBracLoc(ReadSourceLocation(Record, Idx)); 129 } 130 131 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) { 132 VisitStmt(S); 133 Reader.RecordSwitchCaseID(S, Record[Idx++]); 134 } 135 136 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) { 137 VisitSwitchCase(S); 138 S->setLHS(Reader.ReadSubExpr()); 139 S->setRHS(Reader.ReadSubExpr()); 140 S->setSubStmt(Reader.ReadSubStmt()); 141 S->setCaseLoc(ReadSourceLocation(Record, Idx)); 142 S->setEllipsisLoc(ReadSourceLocation(Record, Idx)); 143 S->setColonLoc(ReadSourceLocation(Record, Idx)); 144 } 145 146 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) { 147 VisitSwitchCase(S); 148 S->setSubStmt(Reader.ReadSubStmt()); 149 S->setDefaultLoc(ReadSourceLocation(Record, Idx)); 150 S->setColonLoc(ReadSourceLocation(Record, Idx)); 151 } 152 153 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) { 154 VisitStmt(S); 155 LabelDecl *LD = ReadDeclAs<LabelDecl>(Record, Idx); 156 LD->setStmt(S); 157 S->setDecl(LD); 158 S->setSubStmt(Reader.ReadSubStmt()); 159 S->setIdentLoc(ReadSourceLocation(Record, Idx)); 160 } 161 162 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) { 163 VisitStmt(S); 164 AttrVec Attrs; 165 Reader.ReadAttributes(F, Attrs, Record, Idx); 166 S->Attrs = Attrs; 167 S->SubStmt = Reader.ReadSubStmt(); 168 S->AttrLoc = ReadSourceLocation(Record, Idx); 169 } 170 171 void ASTStmtReader::VisitIfStmt(IfStmt *S) { 172 VisitStmt(S); 173 S->setConditionVariable(Reader.getContext(), 174 ReadDeclAs<VarDecl>(Record, Idx)); 175 S->setCond(Reader.ReadSubExpr()); 176 S->setThen(Reader.ReadSubStmt()); 177 S->setElse(Reader.ReadSubStmt()); 178 S->setIfLoc(ReadSourceLocation(Record, Idx)); 179 S->setElseLoc(ReadSourceLocation(Record, Idx)); 180 } 181 182 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) { 183 VisitStmt(S); 184 S->setConditionVariable(Reader.getContext(), 185 ReadDeclAs<VarDecl>(Record, Idx)); 186 S->setCond(Reader.ReadSubExpr()); 187 S->setBody(Reader.ReadSubStmt()); 188 S->setSwitchLoc(ReadSourceLocation(Record, Idx)); 189 if (Record[Idx++]) 190 S->setAllEnumCasesCovered(); 191 192 SwitchCase *PrevSC = 0; 193 for (unsigned N = Record.size(); Idx != N; ++Idx) { 194 SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]); 195 if (PrevSC) 196 PrevSC->setNextSwitchCase(SC); 197 else 198 S->setSwitchCaseList(SC); 199 200 PrevSC = SC; 201 } 202 } 203 204 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) { 205 VisitStmt(S); 206 S->setConditionVariable(Reader.getContext(), 207 ReadDeclAs<VarDecl>(Record, Idx)); 208 209 S->setCond(Reader.ReadSubExpr()); 210 S->setBody(Reader.ReadSubStmt()); 211 S->setWhileLoc(ReadSourceLocation(Record, Idx)); 212 } 213 214 void ASTStmtReader::VisitDoStmt(DoStmt *S) { 215 VisitStmt(S); 216 S->setCond(Reader.ReadSubExpr()); 217 S->setBody(Reader.ReadSubStmt()); 218 S->setDoLoc(ReadSourceLocation(Record, Idx)); 219 S->setWhileLoc(ReadSourceLocation(Record, Idx)); 220 S->setRParenLoc(ReadSourceLocation(Record, Idx)); 221 } 222 223 void ASTStmtReader::VisitForStmt(ForStmt *S) { 224 VisitStmt(S); 225 S->setInit(Reader.ReadSubStmt()); 226 S->setCond(Reader.ReadSubExpr()); 227 S->setConditionVariable(Reader.getContext(), 228 ReadDeclAs<VarDecl>(Record, Idx)); 229 S->setInc(Reader.ReadSubExpr()); 230 S->setBody(Reader.ReadSubStmt()); 231 S->setForLoc(ReadSourceLocation(Record, Idx)); 232 S->setLParenLoc(ReadSourceLocation(Record, Idx)); 233 S->setRParenLoc(ReadSourceLocation(Record, Idx)); 234 } 235 236 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) { 237 VisitStmt(S); 238 S->setLabel(ReadDeclAs<LabelDecl>(Record, Idx)); 239 S->setGotoLoc(ReadSourceLocation(Record, Idx)); 240 S->setLabelLoc(ReadSourceLocation(Record, Idx)); 241 } 242 243 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) { 244 VisitStmt(S); 245 S->setGotoLoc(ReadSourceLocation(Record, Idx)); 246 S->setStarLoc(ReadSourceLocation(Record, Idx)); 247 S->setTarget(Reader.ReadSubExpr()); 248 } 249 250 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) { 251 VisitStmt(S); 252 S->setContinueLoc(ReadSourceLocation(Record, Idx)); 253 } 254 255 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) { 256 VisitStmt(S); 257 S->setBreakLoc(ReadSourceLocation(Record, Idx)); 258 } 259 260 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) { 261 VisitStmt(S); 262 S->setRetValue(Reader.ReadSubExpr()); 263 S->setReturnLoc(ReadSourceLocation(Record, Idx)); 264 S->setNRVOCandidate(ReadDeclAs<VarDecl>(Record, Idx)); 265 } 266 267 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) { 268 VisitStmt(S); 269 S->setStartLoc(ReadSourceLocation(Record, Idx)); 270 S->setEndLoc(ReadSourceLocation(Record, Idx)); 271 272 if (Idx + 1 == Record.size()) { 273 // Single declaration 274 S->setDeclGroup(DeclGroupRef(ReadDecl(Record, Idx))); 275 } else { 276 SmallVector<Decl *, 16> Decls; 277 Decls.reserve(Record.size() - Idx); 278 for (unsigned N = Record.size(); Idx != N; ) 279 Decls.push_back(ReadDecl(Record, Idx)); 280 S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Reader.getContext(), 281 Decls.data(), 282 Decls.size()))); 283 } 284 } 285 286 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) { 287 VisitStmt(S); 288 unsigned NumOutputs = Record[Idx++]; 289 unsigned NumInputs = Record[Idx++]; 290 unsigned NumClobbers = Record[Idx++]; 291 S->setAsmLoc(ReadSourceLocation(Record, Idx)); 292 S->setRParenLoc(ReadSourceLocation(Record, Idx)); 293 S->setVolatile(Record[Idx++]); 294 S->setSimple(Record[Idx++]); 295 S->setMSAsm(Record[Idx++]); 296 297 S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt())); 298 299 // Outputs and inputs 300 SmallVector<IdentifierInfo *, 16> Names; 301 SmallVector<StringLiteral*, 16> Constraints; 302 SmallVector<Stmt*, 16> Exprs; 303 for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) { 304 Names.push_back(Reader.GetIdentifierInfo(F, Record, Idx)); 305 Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt())); 306 Exprs.push_back(Reader.ReadSubStmt()); 307 } 308 309 // Constraints 310 SmallVector<StringLiteral*, 16> Clobbers; 311 for (unsigned I = 0; I != NumClobbers; ++I) 312 Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt())); 313 314 S->setOutputsAndInputsAndClobbers(Reader.getContext(), 315 Names.data(), Constraints.data(), 316 Exprs.data(), NumOutputs, NumInputs, 317 Clobbers.data(), NumClobbers); 318 } 319 320 void ASTStmtReader::VisitExpr(Expr *E) { 321 VisitStmt(E); 322 E->setType(Reader.readType(F, Record, Idx)); 323 E->setTypeDependent(Record[Idx++]); 324 E->setValueDependent(Record[Idx++]); 325 E->setInstantiationDependent(Record[Idx++]); 326 E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++]; 327 E->setValueKind(static_cast<ExprValueKind>(Record[Idx++])); 328 E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++])); 329 assert(Idx == NumExprFields && "Incorrect expression field count"); 330 } 331 332 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) { 333 VisitExpr(E); 334 E->setLocation(ReadSourceLocation(Record, Idx)); 335 E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]); 336 } 337 338 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) { 339 VisitExpr(E); 340 341 E->DeclRefExprBits.HasQualifier = Record[Idx++]; 342 E->DeclRefExprBits.HasFoundDecl = Record[Idx++]; 343 E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record[Idx++]; 344 E->DeclRefExprBits.HadMultipleCandidates = Record[Idx++]; 345 E->DeclRefExprBits.RefersToEnclosingLocal = Record[Idx++]; 346 unsigned NumTemplateArgs = 0; 347 if (E->hasTemplateKWAndArgsInfo()) 348 NumTemplateArgs = Record[Idx++]; 349 350 if (E->hasQualifier()) 351 E->getInternalQualifierLoc() 352 = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 353 354 if (E->hasFoundDecl()) 355 E->getInternalFoundDecl() = ReadDeclAs<NamedDecl>(Record, Idx); 356 357 if (E->hasTemplateKWAndArgsInfo()) 358 ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(), 359 NumTemplateArgs); 360 361 E->setDecl(ReadDeclAs<ValueDecl>(Record, Idx)); 362 E->setLocation(ReadSourceLocation(Record, Idx)); 363 ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx); 364 } 365 366 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) { 367 VisitExpr(E); 368 E->setLocation(ReadSourceLocation(Record, Idx)); 369 E->setValue(Reader.getContext(), Reader.ReadAPInt(Record, Idx)); 370 } 371 372 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) { 373 VisitExpr(E); 374 E->setValue(Reader.getContext(), Reader.ReadAPFloat(Record, Idx)); 375 E->setExact(Record[Idx++]); 376 E->setLocation(ReadSourceLocation(Record, Idx)); 377 } 378 379 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) { 380 VisitExpr(E); 381 E->setSubExpr(Reader.ReadSubExpr()); 382 } 383 384 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) { 385 VisitExpr(E); 386 unsigned Len = Record[Idx++]; 387 assert(Record[Idx] == E->getNumConcatenated() && 388 "Wrong number of concatenated tokens!"); 389 ++Idx; 390 StringLiteral::StringKind kind = 391 static_cast<StringLiteral::StringKind>(Record[Idx++]); 392 bool isPascal = Record[Idx++]; 393 394 // Read string data 395 SmallString<16> Str(&Record[Idx], &Record[Idx] + Len); 396 E->setString(Reader.getContext(), Str.str(), kind, isPascal); 397 Idx += Len; 398 399 // Read source locations 400 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I) 401 E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx)); 402 } 403 404 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) { 405 VisitExpr(E); 406 E->setValue(Record[Idx++]); 407 E->setLocation(ReadSourceLocation(Record, Idx)); 408 E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record[Idx++])); 409 } 410 411 void ASTStmtReader::VisitParenExpr(ParenExpr *E) { 412 VisitExpr(E); 413 E->setLParen(ReadSourceLocation(Record, Idx)); 414 E->setRParen(ReadSourceLocation(Record, Idx)); 415 E->setSubExpr(Reader.ReadSubExpr()); 416 } 417 418 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) { 419 VisitExpr(E); 420 unsigned NumExprs = Record[Idx++]; 421 E->Exprs = new (Reader.getContext()) Stmt*[NumExprs]; 422 for (unsigned i = 0; i != NumExprs; ++i) 423 E->Exprs[i] = Reader.ReadSubStmt(); 424 E->NumExprs = NumExprs; 425 E->LParenLoc = ReadSourceLocation(Record, Idx); 426 E->RParenLoc = ReadSourceLocation(Record, Idx); 427 } 428 429 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) { 430 VisitExpr(E); 431 E->setSubExpr(Reader.ReadSubExpr()); 432 E->setOpcode((UnaryOperator::Opcode)Record[Idx++]); 433 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 434 } 435 436 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) { 437 typedef OffsetOfExpr::OffsetOfNode Node; 438 VisitExpr(E); 439 assert(E->getNumComponents() == Record[Idx]); 440 ++Idx; 441 assert(E->getNumExpressions() == Record[Idx]); 442 ++Idx; 443 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 444 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 445 E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx)); 446 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 447 Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]); 448 SourceLocation Start = ReadSourceLocation(Record, Idx); 449 SourceLocation End = ReadSourceLocation(Record, Idx); 450 switch (Kind) { 451 case Node::Array: 452 E->setComponent(I, Node(Start, Record[Idx++], End)); 453 break; 454 455 case Node::Field: 456 E->setComponent(I, Node(Start, ReadDeclAs<FieldDecl>(Record, Idx), End)); 457 break; 458 459 case Node::Identifier: 460 E->setComponent(I, 461 Node(Start, 462 Reader.GetIdentifierInfo(F, Record, Idx), 463 End)); 464 break; 465 466 case Node::Base: { 467 CXXBaseSpecifier *Base = new (Reader.getContext()) CXXBaseSpecifier(); 468 *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx); 469 E->setComponent(I, Node(Base)); 470 break; 471 } 472 } 473 } 474 475 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) 476 E->setIndexExpr(I, Reader.ReadSubExpr()); 477 } 478 479 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { 480 VisitExpr(E); 481 E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++])); 482 if (Record[Idx] == 0) { 483 E->setArgument(Reader.ReadSubExpr()); 484 ++Idx; 485 } else { 486 E->setArgument(GetTypeSourceInfo(Record, Idx)); 487 } 488 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 489 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 490 } 491 492 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 493 VisitExpr(E); 494 E->setLHS(Reader.ReadSubExpr()); 495 E->setRHS(Reader.ReadSubExpr()); 496 E->setRBracketLoc(ReadSourceLocation(Record, Idx)); 497 } 498 499 void ASTStmtReader::VisitCallExpr(CallExpr *E) { 500 VisitExpr(E); 501 E->setNumArgs(Reader.getContext(), Record[Idx++]); 502 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 503 E->setCallee(Reader.ReadSubExpr()); 504 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 505 E->setArg(I, Reader.ReadSubExpr()); 506 } 507 508 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 509 VisitCallExpr(E); 510 } 511 512 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) { 513 // Don't call VisitExpr, this is fully initialized at creation. 514 assert(E->getStmtClass() == Stmt::MemberExprClass && 515 "It's a subclass, we must advance Idx!"); 516 } 517 518 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) { 519 VisitExpr(E); 520 E->setBase(Reader.ReadSubExpr()); 521 E->setIsaMemberLoc(ReadSourceLocation(Record, Idx)); 522 E->setArrow(Record[Idx++]); 523 } 524 525 void ASTStmtReader:: 526 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 527 VisitExpr(E); 528 E->Operand = Reader.ReadSubExpr(); 529 E->setShouldCopy(Record[Idx++]); 530 } 531 532 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 533 VisitExplicitCastExpr(E); 534 E->LParenLoc = ReadSourceLocation(Record, Idx); 535 E->BridgeKeywordLoc = ReadSourceLocation(Record, Idx); 536 E->Kind = Record[Idx++]; 537 } 538 539 void ASTStmtReader::VisitCastExpr(CastExpr *E) { 540 VisitExpr(E); 541 unsigned NumBaseSpecs = Record[Idx++]; 542 assert(NumBaseSpecs == E->path_size()); 543 E->setSubExpr(Reader.ReadSubExpr()); 544 E->setCastKind((CastExpr::CastKind)Record[Idx++]); 545 CastExpr::path_iterator BaseI = E->path_begin(); 546 while (NumBaseSpecs--) { 547 CXXBaseSpecifier *BaseSpec = new (Reader.getContext()) CXXBaseSpecifier; 548 *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx); 549 *BaseI++ = BaseSpec; 550 } 551 } 552 553 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) { 554 VisitExpr(E); 555 E->setLHS(Reader.ReadSubExpr()); 556 E->setRHS(Reader.ReadSubExpr()); 557 E->setOpcode((BinaryOperator::Opcode)Record[Idx++]); 558 E->setOperatorLoc(ReadSourceLocation(Record, Idx)); 559 } 560 561 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 562 VisitBinaryOperator(E); 563 E->setComputationLHSType(Reader.readType(F, Record, Idx)); 564 E->setComputationResultType(Reader.readType(F, Record, Idx)); 565 } 566 567 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) { 568 VisitExpr(E); 569 E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr(); 570 E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr(); 571 E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr(); 572 E->QuestionLoc = ReadSourceLocation(Record, Idx); 573 E->ColonLoc = ReadSourceLocation(Record, Idx); 574 } 575 576 void 577 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { 578 VisitExpr(E); 579 E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr()); 580 E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr(); 581 E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr(); 582 E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr(); 583 E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr(); 584 E->QuestionLoc = ReadSourceLocation(Record, Idx); 585 E->ColonLoc = ReadSourceLocation(Record, Idx); 586 } 587 588 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) { 589 VisitCastExpr(E); 590 } 591 592 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) { 593 VisitCastExpr(E); 594 E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx)); 595 } 596 597 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) { 598 VisitExplicitCastExpr(E); 599 E->setLParenLoc(ReadSourceLocation(Record, Idx)); 600 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 601 } 602 603 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 604 VisitExpr(E); 605 E->setLParenLoc(ReadSourceLocation(Record, Idx)); 606 E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx)); 607 E->setInitializer(Reader.ReadSubExpr()); 608 E->setFileScope(Record[Idx++]); 609 } 610 611 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { 612 VisitExpr(E); 613 E->setBase(Reader.ReadSubExpr()); 614 E->setAccessor(Reader.GetIdentifierInfo(F, Record, Idx)); 615 E->setAccessorLoc(ReadSourceLocation(Record, Idx)); 616 } 617 618 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) { 619 VisitExpr(E); 620 E->setSyntacticForm(cast_or_null<InitListExpr>(Reader.ReadSubStmt())); 621 E->setLBraceLoc(ReadSourceLocation(Record, Idx)); 622 E->setRBraceLoc(ReadSourceLocation(Record, Idx)); 623 bool isArrayFiller = Record[Idx++]; 624 Expr *filler = 0; 625 if (isArrayFiller) { 626 filler = Reader.ReadSubExpr(); 627 E->ArrayFillerOrUnionFieldInit = filler; 628 } else 629 E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>(Record, Idx); 630 E->sawArrayRangeDesignator(Record[Idx++]); 631 E->setInitializesStdInitializerList(Record[Idx++]); 632 unsigned NumInits = Record[Idx++]; 633 E->reserveInits(Reader.getContext(), NumInits); 634 if (isArrayFiller) { 635 for (unsigned I = 0; I != NumInits; ++I) { 636 Expr *init = Reader.ReadSubExpr(); 637 E->updateInit(Reader.getContext(), I, init ? init : filler); 638 } 639 } else { 640 for (unsigned I = 0; I != NumInits; ++I) 641 E->updateInit(Reader.getContext(), I, Reader.ReadSubExpr()); 642 } 643 } 644 645 void 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(ReadSourceLocation(Record, Idx)); 654 E->setGNUSyntax(Record[Idx++]); 655 656 SmallVector<Designator, 4> Designators; 657 while (Idx < Record.size()) { 658 switch ((DesignatorTypes)Record[Idx++]) { 659 case DESIG_FIELD_DECL: { 660 FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx); 661 SourceLocation DotLoc 662 = ReadSourceLocation(Record, Idx); 663 SourceLocation FieldLoc 664 = ReadSourceLocation(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(F, Record, Idx); 673 SourceLocation DotLoc 674 = ReadSourceLocation(Record, Idx); 675 SourceLocation FieldLoc 676 = ReadSourceLocation(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 = ReadSourceLocation(Record, Idx); 685 SourceLocation RBracketLoc 686 = ReadSourceLocation(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 = ReadSourceLocation(Record, Idx); 695 SourceLocation EllipsisLoc 696 = ReadSourceLocation(Record, Idx); 697 SourceLocation RBracketLoc 698 = ReadSourceLocation(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 709 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 710 VisitExpr(E); 711 } 712 713 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) { 714 VisitExpr(E); 715 E->setSubExpr(Reader.ReadSubExpr()); 716 E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx)); 717 E->setBuiltinLoc(ReadSourceLocation(Record, Idx)); 718 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 719 } 720 721 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) { 722 VisitExpr(E); 723 E->setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 724 E->setLabelLoc(ReadSourceLocation(Record, Idx)); 725 E->setLabel(ReadDeclAs<LabelDecl>(Record, Idx)); 726 } 727 728 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) { 729 VisitExpr(E); 730 E->setLParenLoc(ReadSourceLocation(Record, Idx)); 731 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 732 E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt())); 733 } 734 735 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) { 736 VisitExpr(E); 737 E->setCond(Reader.ReadSubExpr()); 738 E->setLHS(Reader.ReadSubExpr()); 739 E->setRHS(Reader.ReadSubExpr()); 740 E->setBuiltinLoc(ReadSourceLocation(Record, Idx)); 741 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 742 } 743 744 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) { 745 VisitExpr(E); 746 E->setTokenLocation(ReadSourceLocation(Record, Idx)); 747 } 748 749 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 750 VisitExpr(E); 751 SmallVector<Expr *, 16> Exprs; 752 unsigned NumExprs = Record[Idx++]; 753 while (NumExprs--) 754 Exprs.push_back(Reader.ReadSubExpr()); 755 E->setExprs(Reader.getContext(), Exprs.data(), Exprs.size()); 756 E->setBuiltinLoc(ReadSourceLocation(Record, Idx)); 757 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 758 } 759 760 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) { 761 VisitExpr(E); 762 E->setBlockDecl(ReadDeclAs<BlockDecl>(Record, Idx)); 763 } 764 765 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) { 766 VisitExpr(E); 767 E->NumAssocs = Record[Idx++]; 768 E->AssocTypes = new (Reader.getContext()) TypeSourceInfo*[E->NumAssocs]; 769 E->SubExprs = 770 new(Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs]; 771 772 E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr(); 773 for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) { 774 E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx); 775 E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr(); 776 } 777 E->ResultIndex = Record[Idx++]; 778 779 E->GenericLoc = ReadSourceLocation(Record, Idx); 780 E->DefaultLoc = ReadSourceLocation(Record, Idx); 781 E->RParenLoc = ReadSourceLocation(Record, Idx); 782 } 783 784 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) { 785 VisitExpr(E); 786 unsigned numSemanticExprs = Record[Idx++]; 787 assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs); 788 E->PseudoObjectExprBits.ResultIndex = Record[Idx++]; 789 790 // Read the syntactic expression. 791 E->getSubExprsBuffer()[0] = Reader.ReadSubExpr(); 792 793 // Read all the semantic expressions. 794 for (unsigned i = 0; i != numSemanticExprs; ++i) { 795 Expr *subExpr = Reader.ReadSubExpr(); 796 E->getSubExprsBuffer()[i+1] = subExpr; 797 } 798 } 799 800 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) { 801 VisitExpr(E); 802 E->Op = AtomicExpr::AtomicOp(Record[Idx++]); 803 E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op); 804 for (unsigned I = 0; I != E->NumSubExprs; ++I) 805 E->SubExprs[I] = Reader.ReadSubExpr(); 806 E->BuiltinLoc = ReadSourceLocation(Record, Idx); 807 E->RParenLoc = ReadSourceLocation(Record, Idx); 808 } 809 810 //===----------------------------------------------------------------------===// 811 // Objective-C Expressions and Statements 812 813 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) { 814 VisitExpr(E); 815 E->setString(cast<StringLiteral>(Reader.ReadSubStmt())); 816 E->setAtLoc(ReadSourceLocation(Record, Idx)); 817 } 818 819 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { 820 VisitExpr(E); 821 // could be one of several IntegerLiteral, FloatLiteral, etc. 822 E->SubExpr = Reader.ReadSubStmt(); 823 E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx); 824 E->Range = ReadSourceRange(Record, Idx); 825 } 826 827 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { 828 VisitExpr(E); 829 unsigned NumElements = Record[Idx++]; 830 assert(NumElements == E->getNumElements() && "Wrong number of elements"); 831 Expr **Elements = E->getElements(); 832 for (unsigned I = 0, N = NumElements; I != N; ++I) 833 Elements[I] = Reader.ReadSubExpr(); 834 E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx); 835 E->Range = ReadSourceRange(Record, Idx); 836 } 837 838 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { 839 VisitExpr(E); 840 unsigned NumElements = Record[Idx++]; 841 assert(NumElements == E->getNumElements() && "Wrong number of elements"); 842 bool HasPackExpansions = Record[Idx++]; 843 assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch"); 844 ObjCDictionaryLiteral::KeyValuePair *KeyValues = E->getKeyValues(); 845 ObjCDictionaryLiteral::ExpansionData *Expansions = E->getExpansionData(); 846 for (unsigned I = 0; I != NumElements; ++I) { 847 KeyValues[I].Key = Reader.ReadSubExpr(); 848 KeyValues[I].Value = Reader.ReadSubExpr(); 849 if (HasPackExpansions) { 850 Expansions[I].EllipsisLoc = ReadSourceLocation(Record, Idx); 851 Expansions[I].NumExpansionsPlusOne = Record[Idx++]; 852 } 853 } 854 E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx); 855 E->Range = ReadSourceRange(Record, Idx); 856 } 857 858 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 859 VisitExpr(E); 860 E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx)); 861 E->setAtLoc(ReadSourceLocation(Record, Idx)); 862 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 863 } 864 865 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 866 VisitExpr(E); 867 E->setSelector(Reader.ReadSelector(F, Record, Idx)); 868 E->setAtLoc(ReadSourceLocation(Record, Idx)); 869 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 870 } 871 872 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 873 VisitExpr(E); 874 E->setProtocol(ReadDeclAs<ObjCProtocolDecl>(Record, Idx)); 875 E->setAtLoc(ReadSourceLocation(Record, Idx)); 876 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 877 } 878 879 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 880 VisitExpr(E); 881 E->setDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx)); 882 E->setLocation(ReadSourceLocation(Record, Idx)); 883 E->setBase(Reader.ReadSubExpr()); 884 E->setIsArrow(Record[Idx++]); 885 E->setIsFreeIvar(Record[Idx++]); 886 } 887 888 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 889 VisitExpr(E); 890 unsigned MethodRefFlags = Record[Idx++]; 891 bool Implicit = Record[Idx++] != 0; 892 if (Implicit) { 893 ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(Record, Idx); 894 ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(Record, Idx); 895 E->setImplicitProperty(Getter, Setter, MethodRefFlags); 896 } else { 897 E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(Record, Idx), 898 MethodRefFlags); 899 } 900 E->setLocation(ReadSourceLocation(Record, Idx)); 901 E->setReceiverLocation(ReadSourceLocation(Record, Idx)); 902 switch (Record[Idx++]) { 903 case 0: 904 E->setBase(Reader.ReadSubExpr()); 905 break; 906 case 1: 907 E->setSuperReceiver(Reader.readType(F, Record, Idx)); 908 break; 909 case 2: 910 E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx)); 911 break; 912 } 913 } 914 915 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { 916 VisitExpr(E); 917 E->setRBracket(ReadSourceLocation(Record, Idx)); 918 E->setBaseExpr(Reader.ReadSubExpr()); 919 E->setKeyExpr(Reader.ReadSubExpr()); 920 E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx); 921 E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx); 922 } 923 924 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { 925 VisitExpr(E); 926 assert(Record[Idx] == E->getNumArgs()); 927 ++Idx; 928 unsigned NumStoredSelLocs = Record[Idx++]; 929 E->SelLocsKind = Record[Idx++]; 930 E->setDelegateInitCall(Record[Idx++]); 931 E->IsImplicit = Record[Idx++]; 932 ObjCMessageExpr::ReceiverKind Kind 933 = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]); 934 switch (Kind) { 935 case ObjCMessageExpr::Instance: 936 E->setInstanceReceiver(Reader.ReadSubExpr()); 937 break; 938 939 case ObjCMessageExpr::Class: 940 E->setClassReceiver(GetTypeSourceInfo(Record, Idx)); 941 break; 942 943 case ObjCMessageExpr::SuperClass: 944 case ObjCMessageExpr::SuperInstance: { 945 QualType T = Reader.readType(F, Record, Idx); 946 SourceLocation SuperLoc = ReadSourceLocation(Record, Idx); 947 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance); 948 break; 949 } 950 } 951 952 assert(Kind == E->getReceiverKind()); 953 954 if (Record[Idx++]) 955 E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx)); 956 else 957 E->setSelector(Reader.ReadSelector(F, Record, Idx)); 958 959 E->LBracLoc = ReadSourceLocation(Record, Idx); 960 E->RBracLoc = ReadSourceLocation(Record, Idx); 961 962 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 963 E->setArg(I, Reader.ReadSubExpr()); 964 965 SourceLocation *Locs = E->getStoredSelLocs(); 966 for (unsigned I = 0; I != NumStoredSelLocs; ++I) 967 Locs[I] = ReadSourceLocation(Record, Idx); 968 } 969 970 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 971 VisitStmt(S); 972 S->setElement(Reader.ReadSubStmt()); 973 S->setCollection(Reader.ReadSubExpr()); 974 S->setBody(Reader.ReadSubStmt()); 975 S->setForLoc(ReadSourceLocation(Record, Idx)); 976 S->setRParenLoc(ReadSourceLocation(Record, Idx)); 977 } 978 979 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 980 VisitStmt(S); 981 S->setCatchBody(Reader.ReadSubStmt()); 982 S->setCatchParamDecl(ReadDeclAs<VarDecl>(Record, Idx)); 983 S->setAtCatchLoc(ReadSourceLocation(Record, Idx)); 984 S->setRParenLoc(ReadSourceLocation(Record, Idx)); 985 } 986 987 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 988 VisitStmt(S); 989 S->setFinallyBody(Reader.ReadSubStmt()); 990 S->setAtFinallyLoc(ReadSourceLocation(Record, Idx)); 991 } 992 993 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { 994 VisitStmt(S); 995 S->setSubStmt(Reader.ReadSubStmt()); 996 S->setAtLoc(ReadSourceLocation(Record, Idx)); 997 } 998 999 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 1000 VisitStmt(S); 1001 assert(Record[Idx] == S->getNumCatchStmts()); 1002 ++Idx; 1003 bool HasFinally = Record[Idx++]; 1004 S->setTryBody(Reader.ReadSubStmt()); 1005 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) 1006 S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt())); 1007 1008 if (HasFinally) 1009 S->setFinallyStmt(Reader.ReadSubStmt()); 1010 S->setAtTryLoc(ReadSourceLocation(Record, Idx)); 1011 } 1012 1013 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { 1014 VisitStmt(S); 1015 S->setSynchExpr(Reader.ReadSubStmt()); 1016 S->setSynchBody(Reader.ReadSubStmt()); 1017 S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx)); 1018 } 1019 1020 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 1021 VisitStmt(S); 1022 S->setThrowExpr(Reader.ReadSubStmt()); 1023 S->setThrowLoc(ReadSourceLocation(Record, Idx)); 1024 } 1025 1026 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { 1027 VisitExpr(E); 1028 E->setValue(Record[Idx++]); 1029 E->setLocation(ReadSourceLocation(Record, Idx)); 1030 } 1031 1032 //===----------------------------------------------------------------------===// 1033 // C++ Expressions and Statements 1034 //===----------------------------------------------------------------------===// 1035 1036 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) { 1037 VisitStmt(S); 1038 S->CatchLoc = ReadSourceLocation(Record, Idx); 1039 S->ExceptionDecl = ReadDeclAs<VarDecl>(Record, Idx); 1040 S->HandlerBlock = Reader.ReadSubStmt(); 1041 } 1042 1043 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) { 1044 VisitStmt(S); 1045 assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?"); 1046 ++Idx; 1047 S->TryLoc = ReadSourceLocation(Record, Idx); 1048 S->getStmts()[0] = Reader.ReadSubStmt(); 1049 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) 1050 S->getStmts()[i + 1] = Reader.ReadSubStmt(); 1051 } 1052 1053 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 1054 VisitStmt(S); 1055 S->setForLoc(ReadSourceLocation(Record, Idx)); 1056 S->setColonLoc(ReadSourceLocation(Record, Idx)); 1057 S->setRParenLoc(ReadSourceLocation(Record, Idx)); 1058 S->setRangeStmt(Reader.ReadSubStmt()); 1059 S->setBeginEndStmt(Reader.ReadSubStmt()); 1060 S->setCond(Reader.ReadSubExpr()); 1061 S->setInc(Reader.ReadSubExpr()); 1062 S->setLoopVarStmt(Reader.ReadSubStmt()); 1063 S->setBody(Reader.ReadSubStmt()); 1064 } 1065 1066 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { 1067 VisitStmt(S); 1068 S->KeywordLoc = ReadSourceLocation(Record, Idx); 1069 S->IsIfExists = Record[Idx++]; 1070 S->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1071 ReadDeclarationNameInfo(S->NameInfo, Record, Idx); 1072 S->SubStmt = Reader.ReadSubStmt(); 1073 } 1074 1075 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 1076 VisitCallExpr(E); 1077 E->setOperator((OverloadedOperatorKind)Record[Idx++]); 1078 } 1079 1080 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { 1081 VisitExpr(E); 1082 E->NumArgs = Record[Idx++]; 1083 if (E->NumArgs) 1084 E->Args = new (Reader.getContext()) Stmt*[E->NumArgs]; 1085 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 1086 E->setArg(I, Reader.ReadSubExpr()); 1087 E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx)); 1088 E->setLocation(ReadSourceLocation(Record, Idx)); 1089 E->setElidable(Record[Idx++]); 1090 E->setHadMultipleCandidates(Record[Idx++]); 1091 E->setRequiresZeroInitialization(Record[Idx++]); 1092 E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]); 1093 E->ParenRange = ReadSourceRange(Record, Idx); 1094 } 1095 1096 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1097 VisitCXXConstructExpr(E); 1098 E->Type = GetTypeSourceInfo(Record, Idx); 1099 } 1100 1101 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) { 1102 VisitExpr(E); 1103 unsigned NumCaptures = Record[Idx++]; 1104 assert(NumCaptures == E->NumCaptures);(void)NumCaptures; 1105 unsigned NumArrayIndexVars = Record[Idx++]; 1106 E->IntroducerRange = ReadSourceRange(Record, Idx); 1107 E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record[Idx++]); 1108 E->ExplicitParams = Record[Idx++]; 1109 E->ExplicitResultType = Record[Idx++]; 1110 E->ClosingBrace = ReadSourceLocation(Record, Idx); 1111 1112 // Read capture initializers. 1113 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), 1114 CEnd = E->capture_init_end(); 1115 C != CEnd; ++C) 1116 *C = Reader.ReadSubExpr(); 1117 1118 // Read array capture index variables. 1119 if (NumArrayIndexVars > 0) { 1120 unsigned *ArrayIndexStarts = E->getArrayIndexStarts(); 1121 for (unsigned I = 0; I != NumCaptures + 1; ++I) 1122 ArrayIndexStarts[I] = Record[Idx++]; 1123 1124 VarDecl **ArrayIndexVars = E->getArrayIndexVars(); 1125 for (unsigned I = 0; I != NumArrayIndexVars; ++I) 1126 ArrayIndexVars[I] = ReadDeclAs<VarDecl>(Record, Idx); 1127 } 1128 } 1129 1130 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 1131 VisitExplicitCastExpr(E); 1132 SourceRange R = ReadSourceRange(Record, Idx); 1133 E->Loc = R.getBegin(); 1134 E->RParenLoc = R.getEnd(); 1135 } 1136 1137 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { 1138 return VisitCXXNamedCastExpr(E); 1139 } 1140 1141 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 1142 return VisitCXXNamedCastExpr(E); 1143 } 1144 1145 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { 1146 return VisitCXXNamedCastExpr(E); 1147 } 1148 1149 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) { 1150 return VisitCXXNamedCastExpr(E); 1151 } 1152 1153 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { 1154 VisitExplicitCastExpr(E); 1155 E->setTypeBeginLoc(ReadSourceLocation(Record, Idx)); 1156 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 1157 } 1158 1159 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) { 1160 VisitCallExpr(E); 1161 E->UDSuffixLoc = ReadSourceLocation(Record, Idx); 1162 } 1163 1164 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 1165 VisitExpr(E); 1166 E->setValue(Record[Idx++]); 1167 E->setLocation(ReadSourceLocation(Record, Idx)); 1168 } 1169 1170 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 1171 VisitExpr(E); 1172 E->setLocation(ReadSourceLocation(Record, Idx)); 1173 } 1174 1175 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 1176 VisitExpr(E); 1177 E->setSourceRange(ReadSourceRange(Record, Idx)); 1178 if (E->isTypeOperand()) { // typeid(int) 1179 E->setTypeOperandSourceInfo( 1180 GetTypeSourceInfo(Record, Idx)); 1181 return; 1182 } 1183 1184 // typeid(42+2) 1185 E->setExprOperand(Reader.ReadSubExpr()); 1186 } 1187 1188 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) { 1189 VisitExpr(E); 1190 E->setLocation(ReadSourceLocation(Record, Idx)); 1191 E->setImplicit(Record[Idx++]); 1192 } 1193 1194 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) { 1195 VisitExpr(E); 1196 E->ThrowLoc = ReadSourceLocation(Record, Idx); 1197 E->Op = Reader.ReadSubExpr(); 1198 E->IsThrownVariableInScope = Record[Idx++]; 1199 } 1200 1201 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 1202 VisitExpr(E); 1203 1204 assert((bool)Record[Idx] == E->Param.getInt() && "We messed up at creation ?"); 1205 ++Idx; // HasOtherExprStored and SubExpr was handled during creation. 1206 E->Param.setPointer(ReadDeclAs<ParmVarDecl>(Record, Idx)); 1207 E->Loc = ReadSourceLocation(Record, Idx); 1208 } 1209 1210 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 1211 VisitExpr(E); 1212 E->setTemporary(Reader.ReadCXXTemporary(F, Record, Idx)); 1213 E->setSubExpr(Reader.ReadSubExpr()); 1214 } 1215 1216 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1217 VisitExpr(E); 1218 E->TypeInfo = GetTypeSourceInfo(Record, Idx); 1219 E->RParenLoc = ReadSourceLocation(Record, Idx); 1220 } 1221 1222 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { 1223 VisitExpr(E); 1224 E->GlobalNew = Record[Idx++]; 1225 bool isArray = Record[Idx++]; 1226 E->UsualArrayDeleteWantsSize = Record[Idx++]; 1227 unsigned NumPlacementArgs = Record[Idx++]; 1228 E->StoredInitializationStyle = Record[Idx++]; 1229 E->setOperatorNew(ReadDeclAs<FunctionDecl>(Record, Idx)); 1230 E->setOperatorDelete(ReadDeclAs<FunctionDecl>(Record, Idx)); 1231 E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx); 1232 E->TypeIdParens = ReadSourceRange(Record, Idx); 1233 E->StartLoc = ReadSourceLocation(Record, Idx); 1234 E->DirectInitRange = ReadSourceRange(Record, Idx); 1235 1236 E->AllocateArgsArray(Reader.getContext(), isArray, NumPlacementArgs, 1237 E->StoredInitializationStyle != 0); 1238 1239 // Install all the subexpressions. 1240 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end(); 1241 I != e; ++I) 1242 *I = Reader.ReadSubStmt(); 1243 } 1244 1245 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 1246 VisitExpr(E); 1247 E->GlobalDelete = Record[Idx++]; 1248 E->ArrayForm = Record[Idx++]; 1249 E->ArrayFormAsWritten = Record[Idx++]; 1250 E->UsualArrayDeleteWantsSize = Record[Idx++]; 1251 E->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx); 1252 E->Argument = Reader.ReadSubExpr(); 1253 E->Loc = ReadSourceLocation(Record, Idx); 1254 } 1255 1256 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1257 VisitExpr(E); 1258 1259 E->Base = Reader.ReadSubExpr(); 1260 E->IsArrow = Record[Idx++]; 1261 E->OperatorLoc = ReadSourceLocation(Record, Idx); 1262 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1263 E->ScopeType = GetTypeSourceInfo(Record, Idx); 1264 E->ColonColonLoc = ReadSourceLocation(Record, Idx); 1265 E->TildeLoc = ReadSourceLocation(Record, Idx); 1266 1267 IdentifierInfo *II = Reader.GetIdentifierInfo(F, Record, Idx); 1268 if (II) 1269 E->setDestroyedType(II, ReadSourceLocation(Record, Idx)); 1270 else 1271 E->setDestroyedType(GetTypeSourceInfo(Record, Idx)); 1272 } 1273 1274 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) { 1275 VisitExpr(E); 1276 1277 unsigned NumObjects = Record[Idx++]; 1278 assert(NumObjects == E->getNumObjects()); 1279 for (unsigned i = 0; i != NumObjects; ++i) 1280 E->getObjectsBuffer()[i] = ReadDeclAs<BlockDecl>(Record, Idx); 1281 1282 E->SubExpr = Reader.ReadSubExpr(); 1283 } 1284 1285 void 1286 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ 1287 VisitExpr(E); 1288 1289 if (Record[Idx++]) // HasTemplateKWAndArgsInfo 1290 ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(), 1291 /*NumTemplateArgs=*/Record[Idx++]); 1292 1293 E->Base = Reader.ReadSubExpr(); 1294 E->BaseType = Reader.readType(F, Record, Idx); 1295 E->IsArrow = Record[Idx++]; 1296 E->OperatorLoc = ReadSourceLocation(Record, Idx); 1297 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1298 E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(Record, Idx); 1299 ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx); 1300 } 1301 1302 void 1303 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 1304 VisitExpr(E); 1305 1306 if (Record[Idx++]) // HasTemplateKWAndArgsInfo 1307 ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(), 1308 /*NumTemplateArgs=*/Record[Idx++]); 1309 1310 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1311 ReadDeclarationNameInfo(E->NameInfo, Record, Idx); 1312 } 1313 1314 void 1315 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { 1316 VisitExpr(E); 1317 assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?"); 1318 ++Idx; // NumArgs; 1319 for (unsigned I = 0, N = E->arg_size(); I != N; ++I) 1320 E->setArg(I, Reader.ReadSubExpr()); 1321 E->Type = GetTypeSourceInfo(Record, Idx); 1322 E->setLParenLoc(ReadSourceLocation(Record, Idx)); 1323 E->setRParenLoc(ReadSourceLocation(Record, Idx)); 1324 } 1325 1326 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) { 1327 VisitExpr(E); 1328 1329 if (Record[Idx++]) // HasTemplateKWAndArgsInfo 1330 ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(), 1331 /*NumTemplateArgs=*/Record[Idx++]); 1332 1333 unsigned NumDecls = Record[Idx++]; 1334 UnresolvedSet<8> Decls; 1335 for (unsigned i = 0; i != NumDecls; ++i) { 1336 NamedDecl *D = ReadDeclAs<NamedDecl>(Record, Idx); 1337 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 1338 Decls.addDecl(D, AS); 1339 } 1340 E->initializeResults(Reader.getContext(), Decls.begin(), Decls.end()); 1341 1342 ReadDeclarationNameInfo(E->NameInfo, Record, Idx); 1343 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1344 } 1345 1346 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 1347 VisitOverloadExpr(E); 1348 E->IsArrow = Record[Idx++]; 1349 E->HasUnresolvedUsing = Record[Idx++]; 1350 E->Base = Reader.ReadSubExpr(); 1351 E->BaseType = Reader.readType(F, Record, Idx); 1352 E->OperatorLoc = ReadSourceLocation(Record, Idx); 1353 } 1354 1355 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 1356 VisitOverloadExpr(E); 1357 E->RequiresADL = Record[Idx++]; 1358 if (E->RequiresADL) 1359 E->StdIsAssociatedNamespace = Record[Idx++]; 1360 E->Overloaded = Record[Idx++]; 1361 E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx); 1362 } 1363 1364 void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 1365 VisitExpr(E); 1366 E->UTT = (UnaryTypeTrait)Record[Idx++]; 1367 E->Value = (bool)Record[Idx++]; 1368 SourceRange Range = ReadSourceRange(Record, Idx); 1369 E->Loc = Range.getBegin(); 1370 E->RParen = Range.getEnd(); 1371 E->QueriedType = GetTypeSourceInfo(Record, Idx); 1372 } 1373 1374 void ASTStmtReader::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 1375 VisitExpr(E); 1376 E->BTT = (BinaryTypeTrait)Record[Idx++]; 1377 E->Value = (bool)Record[Idx++]; 1378 SourceRange Range = ReadSourceRange(Record, Idx); 1379 E->Loc = Range.getBegin(); 1380 E->RParen = Range.getEnd(); 1381 E->LhsType = GetTypeSourceInfo(Record, Idx); 1382 E->RhsType = GetTypeSourceInfo(Record, Idx); 1383 } 1384 1385 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) { 1386 VisitExpr(E); 1387 E->TypeTraitExprBits.NumArgs = Record[Idx++]; 1388 E->TypeTraitExprBits.Kind = Record[Idx++]; 1389 E->TypeTraitExprBits.Value = Record[Idx++]; 1390 1391 TypeSourceInfo **Args = E->getTypeSourceInfos(); 1392 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 1393 Args[I] = GetTypeSourceInfo(Record, Idx); 1394 } 1395 1396 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 1397 VisitExpr(E); 1398 E->ATT = (ArrayTypeTrait)Record[Idx++]; 1399 E->Value = (unsigned int)Record[Idx++]; 1400 SourceRange Range = ReadSourceRange(Record, Idx); 1401 E->Loc = Range.getBegin(); 1402 E->RParen = Range.getEnd(); 1403 E->QueriedType = GetTypeSourceInfo(Record, Idx); 1404 } 1405 1406 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 1407 VisitExpr(E); 1408 E->ET = (ExpressionTrait)Record[Idx++]; 1409 E->Value = (bool)Record[Idx++]; 1410 SourceRange Range = ReadSourceRange(Record, Idx); 1411 E->QueriedExpression = Reader.ReadSubExpr(); 1412 E->Loc = Range.getBegin(); 1413 E->RParen = Range.getEnd(); 1414 } 1415 1416 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 1417 VisitExpr(E); 1418 E->Value = (bool)Record[Idx++]; 1419 E->Range = ReadSourceRange(Record, Idx); 1420 E->Operand = Reader.ReadSubExpr(); 1421 } 1422 1423 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) { 1424 VisitExpr(E); 1425 E->EllipsisLoc = ReadSourceLocation(Record, Idx); 1426 E->NumExpansions = Record[Idx++]; 1427 E->Pattern = Reader.ReadSubExpr(); 1428 } 1429 1430 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 1431 VisitExpr(E); 1432 E->OperatorLoc = ReadSourceLocation(Record, Idx); 1433 E->PackLoc = ReadSourceLocation(Record, Idx); 1434 E->RParenLoc = ReadSourceLocation(Record, Idx); 1435 E->Length = Record[Idx++]; 1436 E->Pack = ReadDeclAs<NamedDecl>(Record, Idx); 1437 } 1438 1439 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr( 1440 SubstNonTypeTemplateParmExpr *E) { 1441 VisitExpr(E); 1442 E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx); 1443 E->NameLoc = ReadSourceLocation(Record, Idx); 1444 E->Replacement = Reader.ReadSubExpr(); 1445 } 1446 1447 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr( 1448 SubstNonTypeTemplateParmPackExpr *E) { 1449 VisitExpr(E); 1450 E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx); 1451 TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx); 1452 if (ArgPack.getKind() != TemplateArgument::Pack) 1453 return; 1454 1455 E->Arguments = ArgPack.pack_begin(); 1456 E->NumArguments = ArgPack.pack_size(); 1457 E->NameLoc = ReadSourceLocation(Record, Idx); 1458 } 1459 1460 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 1461 VisitExpr(E); 1462 E->Temporary = Reader.ReadSubExpr(); 1463 } 1464 1465 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 1466 VisitExpr(E); 1467 E->SourceExpr = Reader.ReadSubExpr(); 1468 E->Loc = ReadSourceLocation(Record, Idx); 1469 } 1470 1471 //===----------------------------------------------------------------------===// 1472 // Microsoft Expressions and Statements 1473 //===----------------------------------------------------------------------===// 1474 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) { 1475 VisitExpr(E); 1476 E->setSourceRange(ReadSourceRange(Record, Idx)); 1477 if (E->isTypeOperand()) { // __uuidof(ComType) 1478 E->setTypeOperandSourceInfo( 1479 GetTypeSourceInfo(Record, Idx)); 1480 return; 1481 } 1482 1483 // __uuidof(expr) 1484 E->setExprOperand(Reader.ReadSubExpr()); 1485 } 1486 1487 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) { 1488 VisitStmt(S); 1489 S->Loc = ReadSourceLocation(Record, Idx); 1490 S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt(); 1491 S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt(); 1492 } 1493 1494 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) { 1495 VisitStmt(S); 1496 S->Loc = ReadSourceLocation(Record, Idx); 1497 S->Block = Reader.ReadSubStmt(); 1498 } 1499 1500 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) { 1501 VisitStmt(S); 1502 S->IsCXXTry = Record[Idx++]; 1503 S->TryLoc = ReadSourceLocation(Record, Idx); 1504 S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt(); 1505 S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt(); 1506 } 1507 1508 //===----------------------------------------------------------------------===// 1509 // CUDA Expressions and Statements 1510 //===----------------------------------------------------------------------===// 1511 1512 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 1513 VisitCallExpr(E); 1514 E->setConfig(cast<CallExpr>(Reader.ReadSubExpr())); 1515 } 1516 1517 //===----------------------------------------------------------------------===// 1518 // OpenCL Expressions and Statements. 1519 //===----------------------------------------------------------------------===// 1520 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) { 1521 VisitExpr(E); 1522 E->BuiltinLoc = ReadSourceLocation(Record, Idx); 1523 E->RParenLoc = ReadSourceLocation(Record, Idx); 1524 E->SrcExpr = Reader.ReadSubExpr(); 1525 } 1526 1527 //===----------------------------------------------------------------------===// 1528 // ASTReader Implementation 1529 //===----------------------------------------------------------------------===// 1530 1531 Stmt *ASTReader::ReadStmt(ModuleFile &F) { 1532 switch (ReadingKind) { 1533 case Read_Decl: 1534 case Read_Type: 1535 return ReadStmtFromStream(F); 1536 case Read_Stmt: 1537 return ReadSubStmt(); 1538 } 1539 1540 llvm_unreachable("ReadingKind not set ?"); 1541 } 1542 1543 Expr *ASTReader::ReadExpr(ModuleFile &F) { 1544 return cast_or_null<Expr>(ReadStmt(F)); 1545 } 1546 1547 Expr *ASTReader::ReadSubExpr() { 1548 return cast_or_null<Expr>(ReadSubStmt()); 1549 } 1550 1551 // Within the bitstream, expressions are stored in Reverse Polish 1552 // Notation, with each of the subexpressions preceding the 1553 // expression they are stored in. Subexpressions are stored from last to first. 1554 // To evaluate expressions, we continue reading expressions and placing them on 1555 // the stack, with expressions having operands removing those operands from the 1556 // stack. Evaluation terminates when we see a STMT_STOP record, and 1557 // the single remaining expression on the stack is our result. 1558 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { 1559 1560 ReadingKindTracker ReadingKind(Read_Stmt, *this); 1561 llvm::BitstreamCursor &Cursor = F.DeclsCursor; 1562 1563 // Map of offset to previously deserialized stmt. The offset points 1564 /// just after the stmt record. 1565 llvm::DenseMap<uint64_t, Stmt *> StmtEntries; 1566 1567 #ifndef NDEBUG 1568 unsigned PrevNumStmts = StmtStack.size(); 1569 #endif 1570 1571 RecordData Record; 1572 unsigned Idx; 1573 ASTStmtReader Reader(*this, F, Cursor, Record, Idx); 1574 Stmt::EmptyShell Empty; 1575 1576 while (true) { 1577 unsigned Code = Cursor.ReadCode(); 1578 if (Code == llvm::bitc::END_BLOCK) { 1579 if (Cursor.ReadBlockEnd()) { 1580 Error("error at end of block in AST file"); 1581 return 0; 1582 } 1583 break; 1584 } 1585 1586 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1587 // No known subblocks, always skip them. 1588 Cursor.ReadSubBlockID(); 1589 if (Cursor.SkipBlock()) { 1590 Error("malformed block record in AST file"); 1591 return 0; 1592 } 1593 continue; 1594 } 1595 1596 if (Code == llvm::bitc::DEFINE_ABBREV) { 1597 Cursor.ReadAbbrevRecord(); 1598 continue; 1599 } 1600 1601 Stmt *S = 0; 1602 Idx = 0; 1603 Record.clear(); 1604 bool Finished = false; 1605 bool IsStmtReference = false; 1606 switch ((StmtCode)Cursor.ReadRecord(Code, Record)) { 1607 case STMT_STOP: 1608 Finished = true; 1609 break; 1610 1611 case STMT_REF_PTR: 1612 IsStmtReference = true; 1613 assert(StmtEntries.find(Record[0]) != StmtEntries.end() && 1614 "No stmt was recorded for this offset reference!"); 1615 S = StmtEntries[Record[Idx++]]; 1616 break; 1617 1618 case STMT_NULL_PTR: 1619 S = 0; 1620 break; 1621 1622 case STMT_NULL: 1623 S = new (Context) NullStmt(Empty); 1624 break; 1625 1626 case STMT_COMPOUND: 1627 S = new (Context) CompoundStmt(Empty); 1628 break; 1629 1630 case STMT_CASE: 1631 S = new (Context) CaseStmt(Empty); 1632 break; 1633 1634 case STMT_DEFAULT: 1635 S = new (Context) DefaultStmt(Empty); 1636 break; 1637 1638 case STMT_LABEL: 1639 S = new (Context) LabelStmt(Empty); 1640 break; 1641 1642 case STMT_ATTRIBUTED: 1643 S = new (Context) AttributedStmt(Empty); 1644 break; 1645 1646 case STMT_IF: 1647 S = new (Context) IfStmt(Empty); 1648 break; 1649 1650 case STMT_SWITCH: 1651 S = new (Context) SwitchStmt(Empty); 1652 break; 1653 1654 case STMT_WHILE: 1655 S = new (Context) WhileStmt(Empty); 1656 break; 1657 1658 case STMT_DO: 1659 S = new (Context) DoStmt(Empty); 1660 break; 1661 1662 case STMT_FOR: 1663 S = new (Context) ForStmt(Empty); 1664 break; 1665 1666 case STMT_GOTO: 1667 S = new (Context) GotoStmt(Empty); 1668 break; 1669 1670 case STMT_INDIRECT_GOTO: 1671 S = new (Context) IndirectGotoStmt(Empty); 1672 break; 1673 1674 case STMT_CONTINUE: 1675 S = new (Context) ContinueStmt(Empty); 1676 break; 1677 1678 case STMT_BREAK: 1679 S = new (Context) BreakStmt(Empty); 1680 break; 1681 1682 case STMT_RETURN: 1683 S = new (Context) ReturnStmt(Empty); 1684 break; 1685 1686 case STMT_DECL: 1687 S = new (Context) DeclStmt(Empty); 1688 break; 1689 1690 case STMT_ASM: 1691 S = new (Context) AsmStmt(Empty); 1692 break; 1693 1694 case EXPR_PREDEFINED: 1695 S = new (Context) PredefinedExpr(Empty); 1696 break; 1697 1698 case EXPR_DECL_REF: 1699 S = DeclRefExpr::CreateEmpty( 1700 Context, 1701 /*HasQualifier=*/Record[ASTStmtReader::NumExprFields], 1702 /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1], 1703 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2], 1704 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ? 1705 Record[ASTStmtReader::NumExprFields + 5] : 0); 1706 break; 1707 1708 case EXPR_INTEGER_LITERAL: 1709 S = IntegerLiteral::Create(Context, Empty); 1710 break; 1711 1712 case EXPR_FLOATING_LITERAL: 1713 S = FloatingLiteral::Create(Context, Empty); 1714 break; 1715 1716 case EXPR_IMAGINARY_LITERAL: 1717 S = new (Context) ImaginaryLiteral(Empty); 1718 break; 1719 1720 case EXPR_STRING_LITERAL: 1721 S = StringLiteral::CreateEmpty(Context, 1722 Record[ASTStmtReader::NumExprFields + 1]); 1723 break; 1724 1725 case EXPR_CHARACTER_LITERAL: 1726 S = new (Context) CharacterLiteral(Empty); 1727 break; 1728 1729 case EXPR_PAREN: 1730 S = new (Context) ParenExpr(Empty); 1731 break; 1732 1733 case EXPR_PAREN_LIST: 1734 S = new (Context) ParenListExpr(Empty); 1735 break; 1736 1737 case EXPR_UNARY_OPERATOR: 1738 S = new (Context) UnaryOperator(Empty); 1739 break; 1740 1741 case EXPR_OFFSETOF: 1742 S = OffsetOfExpr::CreateEmpty(Context, 1743 Record[ASTStmtReader::NumExprFields], 1744 Record[ASTStmtReader::NumExprFields + 1]); 1745 break; 1746 1747 case EXPR_SIZEOF_ALIGN_OF: 1748 S = new (Context) UnaryExprOrTypeTraitExpr(Empty); 1749 break; 1750 1751 case EXPR_ARRAY_SUBSCRIPT: 1752 S = new (Context) ArraySubscriptExpr(Empty); 1753 break; 1754 1755 case EXPR_CALL: 1756 S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty); 1757 break; 1758 1759 case EXPR_MEMBER: { 1760 // We load everything here and fully initialize it at creation. 1761 // That way we can use MemberExpr::Create and don't have to duplicate its 1762 // logic with a MemberExpr::CreateEmpty. 1763 1764 assert(Idx == 0); 1765 NestedNameSpecifierLoc QualifierLoc; 1766 if (Record[Idx++]) { // HasQualifier. 1767 QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 1768 } 1769 1770 SourceLocation TemplateKWLoc; 1771 TemplateArgumentListInfo ArgInfo; 1772 bool HasTemplateKWAndArgsInfo = Record[Idx++]; 1773 if (HasTemplateKWAndArgsInfo) { 1774 TemplateKWLoc = ReadSourceLocation(F, Record, Idx); 1775 unsigned NumTemplateArgs = Record[Idx++]; 1776 ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx)); 1777 ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx)); 1778 for (unsigned i = 0; i != NumTemplateArgs; ++i) 1779 ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx)); 1780 } 1781 1782 bool HadMultipleCandidates = Record[Idx++]; 1783 1784 NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx); 1785 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 1786 DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS); 1787 1788 QualType T = readType(F, Record, Idx); 1789 ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]); 1790 ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]); 1791 Expr *Base = ReadSubExpr(); 1792 ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx); 1793 SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx); 1794 DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc); 1795 bool IsArrow = Record[Idx++]; 1796 1797 S = MemberExpr::Create(Context, Base, IsArrow, QualifierLoc, 1798 TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo, 1799 HasTemplateKWAndArgsInfo ? &ArgInfo : 0, 1800 T, VK, OK); 1801 ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc, 1802 MemberD->getDeclName(), Record, Idx); 1803 if (HadMultipleCandidates) 1804 cast<MemberExpr>(S)->setHadMultipleCandidates(true); 1805 break; 1806 } 1807 1808 case EXPR_BINARY_OPERATOR: 1809 S = new (Context) BinaryOperator(Empty); 1810 break; 1811 1812 case EXPR_COMPOUND_ASSIGN_OPERATOR: 1813 S = new (Context) CompoundAssignOperator(Empty); 1814 break; 1815 1816 case EXPR_CONDITIONAL_OPERATOR: 1817 S = new (Context) ConditionalOperator(Empty); 1818 break; 1819 1820 case EXPR_BINARY_CONDITIONAL_OPERATOR: 1821 S = new (Context) BinaryConditionalOperator(Empty); 1822 break; 1823 1824 case EXPR_IMPLICIT_CAST: 1825 S = ImplicitCastExpr::CreateEmpty(Context, 1826 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1827 break; 1828 1829 case EXPR_CSTYLE_CAST: 1830 S = CStyleCastExpr::CreateEmpty(Context, 1831 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 1832 break; 1833 1834 case EXPR_COMPOUND_LITERAL: 1835 S = new (Context) CompoundLiteralExpr(Empty); 1836 break; 1837 1838 case EXPR_EXT_VECTOR_ELEMENT: 1839 S = new (Context) ExtVectorElementExpr(Empty); 1840 break; 1841 1842 case EXPR_INIT_LIST: 1843 S = new (Context) InitListExpr(getContext(), Empty); 1844 break; 1845 1846 case EXPR_DESIGNATED_INIT: 1847 S = DesignatedInitExpr::CreateEmpty(Context, 1848 Record[ASTStmtReader::NumExprFields] - 1); 1849 1850 break; 1851 1852 case EXPR_IMPLICIT_VALUE_INIT: 1853 S = new (Context) ImplicitValueInitExpr(Empty); 1854 break; 1855 1856 case EXPR_VA_ARG: 1857 S = new (Context) VAArgExpr(Empty); 1858 break; 1859 1860 case EXPR_ADDR_LABEL: 1861 S = new (Context) AddrLabelExpr(Empty); 1862 break; 1863 1864 case EXPR_STMT: 1865 S = new (Context) StmtExpr(Empty); 1866 break; 1867 1868 case EXPR_CHOOSE: 1869 S = new (Context) ChooseExpr(Empty); 1870 break; 1871 1872 case EXPR_GNU_NULL: 1873 S = new (Context) GNUNullExpr(Empty); 1874 break; 1875 1876 case EXPR_SHUFFLE_VECTOR: 1877 S = new (Context) ShuffleVectorExpr(Empty); 1878 break; 1879 1880 case EXPR_BLOCK: 1881 S = new (Context) BlockExpr(Empty); 1882 break; 1883 1884 case EXPR_GENERIC_SELECTION: 1885 S = new (Context) GenericSelectionExpr(Empty); 1886 break; 1887 1888 case EXPR_OBJC_STRING_LITERAL: 1889 S = new (Context) ObjCStringLiteral(Empty); 1890 break; 1891 case EXPR_OBJC_BOXED_EXPRESSION: 1892 S = new (Context) ObjCBoxedExpr(Empty); 1893 break; 1894 case EXPR_OBJC_ARRAY_LITERAL: 1895 S = ObjCArrayLiteral::CreateEmpty(Context, 1896 Record[ASTStmtReader::NumExprFields]); 1897 break; 1898 case EXPR_OBJC_DICTIONARY_LITERAL: 1899 S = ObjCDictionaryLiteral::CreateEmpty(Context, 1900 Record[ASTStmtReader::NumExprFields], 1901 Record[ASTStmtReader::NumExprFields + 1]); 1902 break; 1903 case EXPR_OBJC_ENCODE: 1904 S = new (Context) ObjCEncodeExpr(Empty); 1905 break; 1906 case EXPR_OBJC_SELECTOR_EXPR: 1907 S = new (Context) ObjCSelectorExpr(Empty); 1908 break; 1909 case EXPR_OBJC_PROTOCOL_EXPR: 1910 S = new (Context) ObjCProtocolExpr(Empty); 1911 break; 1912 case EXPR_OBJC_IVAR_REF_EXPR: 1913 S = new (Context) ObjCIvarRefExpr(Empty); 1914 break; 1915 case EXPR_OBJC_PROPERTY_REF_EXPR: 1916 S = new (Context) ObjCPropertyRefExpr(Empty); 1917 break; 1918 case EXPR_OBJC_SUBSCRIPT_REF_EXPR: 1919 S = new (Context) ObjCSubscriptRefExpr(Empty); 1920 break; 1921 case EXPR_OBJC_KVC_REF_EXPR: 1922 llvm_unreachable("mismatching AST file"); 1923 case EXPR_OBJC_MESSAGE_EXPR: 1924 S = ObjCMessageExpr::CreateEmpty(Context, 1925 Record[ASTStmtReader::NumExprFields], 1926 Record[ASTStmtReader::NumExprFields + 1]); 1927 break; 1928 case EXPR_OBJC_ISA: 1929 S = new (Context) ObjCIsaExpr(Empty); 1930 break; 1931 case EXPR_OBJC_INDIRECT_COPY_RESTORE: 1932 S = new (Context) ObjCIndirectCopyRestoreExpr(Empty); 1933 break; 1934 case EXPR_OBJC_BRIDGED_CAST: 1935 S = new (Context) ObjCBridgedCastExpr(Empty); 1936 break; 1937 case STMT_OBJC_FOR_COLLECTION: 1938 S = new (Context) ObjCForCollectionStmt(Empty); 1939 break; 1940 case STMT_OBJC_CATCH: 1941 S = new (Context) ObjCAtCatchStmt(Empty); 1942 break; 1943 case STMT_OBJC_FINALLY: 1944 S = new (Context) ObjCAtFinallyStmt(Empty); 1945 break; 1946 case STMT_OBJC_AT_TRY: 1947 S = ObjCAtTryStmt::CreateEmpty(Context, 1948 Record[ASTStmtReader::NumStmtFields], 1949 Record[ASTStmtReader::NumStmtFields + 1]); 1950 break; 1951 case STMT_OBJC_AT_SYNCHRONIZED: 1952 S = new (Context) ObjCAtSynchronizedStmt(Empty); 1953 break; 1954 case STMT_OBJC_AT_THROW: 1955 S = new (Context) ObjCAtThrowStmt(Empty); 1956 break; 1957 case STMT_OBJC_AUTORELEASE_POOL: 1958 S = new (Context) ObjCAutoreleasePoolStmt(Empty); 1959 break; 1960 case EXPR_OBJC_BOOL_LITERAL: 1961 S = new (Context) ObjCBoolLiteralExpr(Empty); 1962 break; 1963 case STMT_SEH_EXCEPT: 1964 S = new (Context) SEHExceptStmt(Empty); 1965 break; 1966 case STMT_SEH_FINALLY: 1967 S = new (Context) SEHFinallyStmt(Empty); 1968 break; 1969 case STMT_SEH_TRY: 1970 S = new (Context) SEHTryStmt(Empty); 1971 break; 1972 case STMT_CXX_CATCH: 1973 S = new (Context) CXXCatchStmt(Empty); 1974 break; 1975 1976 case STMT_CXX_TRY: 1977 S = CXXTryStmt::Create(Context, Empty, 1978 /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]); 1979 break; 1980 1981 case STMT_CXX_FOR_RANGE: 1982 S = new (Context) CXXForRangeStmt(Empty); 1983 break; 1984 1985 case STMT_MS_DEPENDENT_EXISTS: 1986 S = new (Context) MSDependentExistsStmt(SourceLocation(), true, 1987 NestedNameSpecifierLoc(), 1988 DeclarationNameInfo(), 1989 0); 1990 break; 1991 1992 case EXPR_CXX_OPERATOR_CALL: 1993 S = new (Context) CXXOperatorCallExpr(Context, Empty); 1994 break; 1995 1996 case EXPR_CXX_MEMBER_CALL: 1997 S = new (Context) CXXMemberCallExpr(Context, Empty); 1998 break; 1999 2000 case EXPR_CXX_CONSTRUCT: 2001 S = new (Context) CXXConstructExpr(Empty); 2002 break; 2003 2004 case EXPR_CXX_TEMPORARY_OBJECT: 2005 S = new (Context) CXXTemporaryObjectExpr(Empty); 2006 break; 2007 2008 case EXPR_CXX_STATIC_CAST: 2009 S = CXXStaticCastExpr::CreateEmpty(Context, 2010 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 2011 break; 2012 2013 case EXPR_CXX_DYNAMIC_CAST: 2014 S = CXXDynamicCastExpr::CreateEmpty(Context, 2015 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 2016 break; 2017 2018 case EXPR_CXX_REINTERPRET_CAST: 2019 S = CXXReinterpretCastExpr::CreateEmpty(Context, 2020 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 2021 break; 2022 2023 case EXPR_CXX_CONST_CAST: 2024 S = CXXConstCastExpr::CreateEmpty(Context); 2025 break; 2026 2027 case EXPR_CXX_FUNCTIONAL_CAST: 2028 S = CXXFunctionalCastExpr::CreateEmpty(Context, 2029 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 2030 break; 2031 2032 case EXPR_USER_DEFINED_LITERAL: 2033 S = new (Context) UserDefinedLiteral(Context, Empty); 2034 break; 2035 2036 case EXPR_CXX_BOOL_LITERAL: 2037 S = new (Context) CXXBoolLiteralExpr(Empty); 2038 break; 2039 2040 case EXPR_CXX_NULL_PTR_LITERAL: 2041 S = new (Context) CXXNullPtrLiteralExpr(Empty); 2042 break; 2043 case EXPR_CXX_TYPEID_EXPR: 2044 S = new (Context) CXXTypeidExpr(Empty, true); 2045 break; 2046 case EXPR_CXX_TYPEID_TYPE: 2047 S = new (Context) CXXTypeidExpr(Empty, false); 2048 break; 2049 case EXPR_CXX_UUIDOF_EXPR: 2050 S = new (Context) CXXUuidofExpr(Empty, true); 2051 break; 2052 case EXPR_CXX_UUIDOF_TYPE: 2053 S = new (Context) CXXUuidofExpr(Empty, false); 2054 break; 2055 case EXPR_CXX_THIS: 2056 S = new (Context) CXXThisExpr(Empty); 2057 break; 2058 case EXPR_CXX_THROW: 2059 S = new (Context) CXXThrowExpr(Empty); 2060 break; 2061 case EXPR_CXX_DEFAULT_ARG: { 2062 bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields]; 2063 if (HasOtherExprStored) { 2064 Expr *SubExpr = ReadSubExpr(); 2065 S = CXXDefaultArgExpr::Create(Context, SourceLocation(), 0, SubExpr); 2066 } else 2067 S = new (Context) CXXDefaultArgExpr(Empty); 2068 break; 2069 } 2070 case EXPR_CXX_BIND_TEMPORARY: 2071 S = new (Context) CXXBindTemporaryExpr(Empty); 2072 break; 2073 2074 case EXPR_CXX_SCALAR_VALUE_INIT: 2075 S = new (Context) CXXScalarValueInitExpr(Empty); 2076 break; 2077 case EXPR_CXX_NEW: 2078 S = new (Context) CXXNewExpr(Empty); 2079 break; 2080 case EXPR_CXX_DELETE: 2081 S = new (Context) CXXDeleteExpr(Empty); 2082 break; 2083 case EXPR_CXX_PSEUDO_DESTRUCTOR: 2084 S = new (Context) CXXPseudoDestructorExpr(Empty); 2085 break; 2086 2087 case EXPR_EXPR_WITH_CLEANUPS: 2088 S = ExprWithCleanups::Create(Context, Empty, 2089 Record[ASTStmtReader::NumExprFields]); 2090 break; 2091 2092 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: 2093 S = CXXDependentScopeMemberExpr::CreateEmpty(Context, 2094 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], 2095 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields] 2096 ? Record[ASTStmtReader::NumExprFields + 1] 2097 : 0); 2098 break; 2099 2100 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: 2101 S = DependentScopeDeclRefExpr::CreateEmpty(Context, 2102 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], 2103 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields] 2104 ? Record[ASTStmtReader::NumExprFields + 1] 2105 : 0); 2106 break; 2107 2108 case EXPR_CXX_UNRESOLVED_CONSTRUCT: 2109 S = CXXUnresolvedConstructExpr::CreateEmpty(Context, 2110 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]); 2111 break; 2112 2113 case EXPR_CXX_UNRESOLVED_MEMBER: 2114 S = UnresolvedMemberExpr::CreateEmpty(Context, 2115 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], 2116 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields] 2117 ? Record[ASTStmtReader::NumExprFields + 1] 2118 : 0); 2119 break; 2120 2121 case EXPR_CXX_UNRESOLVED_LOOKUP: 2122 S = UnresolvedLookupExpr::CreateEmpty(Context, 2123 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], 2124 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields] 2125 ? Record[ASTStmtReader::NumExprFields + 1] 2126 : 0); 2127 break; 2128 2129 case EXPR_CXX_UNARY_TYPE_TRAIT: 2130 S = new (Context) UnaryTypeTraitExpr(Empty); 2131 break; 2132 2133 case EXPR_BINARY_TYPE_TRAIT: 2134 S = new (Context) BinaryTypeTraitExpr(Empty); 2135 break; 2136 2137 case EXPR_TYPE_TRAIT: 2138 S = TypeTraitExpr::CreateDeserialized(Context, 2139 Record[ASTStmtReader::NumExprFields]); 2140 break; 2141 2142 case EXPR_ARRAY_TYPE_TRAIT: 2143 S = new (Context) ArrayTypeTraitExpr(Empty); 2144 break; 2145 2146 case EXPR_CXX_EXPRESSION_TRAIT: 2147 S = new (Context) ExpressionTraitExpr(Empty); 2148 break; 2149 2150 case EXPR_CXX_NOEXCEPT: 2151 S = new (Context) CXXNoexceptExpr(Empty); 2152 break; 2153 2154 case EXPR_PACK_EXPANSION: 2155 S = new (Context) PackExpansionExpr(Empty); 2156 break; 2157 2158 case EXPR_SIZEOF_PACK: 2159 S = new (Context) SizeOfPackExpr(Empty); 2160 break; 2161 2162 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM: 2163 S = new (Context) SubstNonTypeTemplateParmExpr(Empty); 2164 break; 2165 2166 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK: 2167 S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty); 2168 break; 2169 2170 case EXPR_MATERIALIZE_TEMPORARY: 2171 S = new (Context) MaterializeTemporaryExpr(Empty); 2172 break; 2173 2174 case EXPR_OPAQUE_VALUE: 2175 S = new (Context) OpaqueValueExpr(Empty); 2176 break; 2177 2178 case EXPR_CUDA_KERNEL_CALL: 2179 S = new (Context) CUDAKernelCallExpr(Context, Empty); 2180 break; 2181 2182 case EXPR_ASTYPE: 2183 S = new (Context) AsTypeExpr(Empty); 2184 break; 2185 2186 case EXPR_PSEUDO_OBJECT: { 2187 unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields]; 2188 S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs); 2189 break; 2190 } 2191 2192 case EXPR_ATOMIC: 2193 S = new (Context) AtomicExpr(Empty); 2194 break; 2195 2196 case EXPR_LAMBDA: { 2197 unsigned NumCaptures = Record[ASTStmtReader::NumExprFields]; 2198 unsigned NumArrayIndexVars = Record[ASTStmtReader::NumExprFields + 1]; 2199 S = LambdaExpr::CreateDeserialized(Context, NumCaptures, 2200 NumArrayIndexVars); 2201 break; 2202 } 2203 } 2204 2205 // We hit a STMT_STOP, so we're done with this expression. 2206 if (Finished) 2207 break; 2208 2209 ++NumStatementsRead; 2210 2211 if (S && !IsStmtReference) { 2212 Reader.Visit(S); 2213 StmtEntries[Cursor.GetCurrentBitNo()] = S; 2214 } 2215 2216 2217 assert(Idx == Record.size() && "Invalid deserialization of statement"); 2218 StmtStack.push_back(S); 2219 } 2220 2221 #ifndef NDEBUG 2222 assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!"); 2223 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"); 2224 #endif 2225 2226 return StmtStack.pop_back_val(); 2227 } 2228