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