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