1 //===--- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Statement/expression deserialization. This implements the
11 // ASTReader::ReadStmt method.
13 //===----------------------------------------------------------------------===//
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 "clang/Lex/Token.h"
21 #include "llvm/ADT/SmallString.h"
22 using namespace clang;
23 using namespace clang::serialization;
27 class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
28 typedef ASTReader::RecordData RecordData;
32 llvm::BitstreamCursor &DeclsCursor;
33 const ASTReader::RecordData &Record;
36 Token ReadToken(const RecordData &R, unsigned &I) {
37 return Reader.ReadToken(F, R, I);
40 SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
41 return Reader.ReadSourceLocation(F, R, I);
44 SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
45 return Reader.ReadSourceRange(F, R, I);
48 std::string ReadString(const RecordData &R, unsigned &I) {
49 return Reader.ReadString(R, I);
52 TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
53 return Reader.GetTypeSourceInfo(F, R, I);
56 serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
57 return Reader.ReadDeclID(F, R, I);
60 Decl *ReadDecl(const RecordData &R, unsigned &I) {
61 return Reader.ReadDecl(F, R, I);
65 T *ReadDeclAs(const RecordData &R, unsigned &I) {
66 return Reader.ReadDeclAs<T>(F, R, I);
69 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
70 const ASTReader::RecordData &R, unsigned &I) {
71 Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
74 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
75 const ASTReader::RecordData &R, unsigned &I) {
76 Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
80 ASTStmtReader(ASTReader &Reader, ModuleFile &F,
81 llvm::BitstreamCursor &Cursor,
82 const ASTReader::RecordData &Record, unsigned &Idx)
83 : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
85 /// \brief The number of record fields required for the Stmt class
87 static const unsigned NumStmtFields = 0;
89 /// \brief The number of record fields required for the Expr class
91 static const unsigned NumExprFields = NumStmtFields + 7;
93 /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
94 void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
95 unsigned NumTemplateArgs);
96 /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
97 void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
98 unsigned NumTemplateArgs);
100 void VisitStmt(Stmt *S);
101 #define STMT(Type, Base) \
102 void Visit##Type(Type *);
103 #include "clang/AST/StmtNodes.inc"
108 ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
109 unsigned NumTemplateArgs) {
110 SourceLocation TemplateKWLoc = ReadSourceLocation(Record, Idx);
111 TemplateArgumentListInfo ArgInfo;
112 ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
113 ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
114 for (unsigned i = 0; i != NumTemplateArgs; ++i)
116 Reader.ReadTemplateArgumentLoc(F, Record, Idx));
117 Args.initializeFrom(TemplateKWLoc, ArgInfo);
120 void ASTStmtReader::VisitStmt(Stmt *S) {
121 assert(Idx == NumStmtFields && "Incorrect statement field count");
124 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
126 S->setSemiLoc(ReadSourceLocation(Record, Idx));
127 S->HasLeadingEmptyMacro = Record[Idx++];
130 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
132 SmallVector<Stmt *, 16> Stmts;
133 unsigned NumStmts = Record[Idx++];
135 Stmts.push_back(Reader.ReadSubStmt());
136 S->setStmts(Reader.getContext(), Stmts.data(), Stmts.size());
137 S->setLBracLoc(ReadSourceLocation(Record, Idx));
138 S->setRBracLoc(ReadSourceLocation(Record, Idx));
141 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
143 Reader.RecordSwitchCaseID(S, Record[Idx++]);
144 S->setKeywordLoc(ReadSourceLocation(Record, Idx));
145 S->setColonLoc(ReadSourceLocation(Record, Idx));
148 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
150 S->setLHS(Reader.ReadSubExpr());
151 S->setRHS(Reader.ReadSubExpr());
152 S->setSubStmt(Reader.ReadSubStmt());
153 S->setEllipsisLoc(ReadSourceLocation(Record, Idx));
156 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
158 S->setSubStmt(Reader.ReadSubStmt());
161 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
163 LabelDecl *LD = ReadDeclAs<LabelDecl>(Record, Idx);
166 S->setSubStmt(Reader.ReadSubStmt());
167 S->setIdentLoc(ReadSourceLocation(Record, Idx));
170 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
172 uint64_t NumAttrs = Record[Idx++];
174 Reader.ReadAttributes(F, Attrs, Record, Idx);
176 assert(NumAttrs == S->NumAttrs);
177 assert(NumAttrs == Attrs.size());
178 std::copy(Attrs.begin(), Attrs.end(), S->Attrs);
179 S->SubStmt = Reader.ReadSubStmt();
180 S->AttrLoc = ReadSourceLocation(Record, Idx);
183 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
185 S->setConditionVariable(Reader.getContext(),
186 ReadDeclAs<VarDecl>(Record, Idx));
187 S->setCond(Reader.ReadSubExpr());
188 S->setThen(Reader.ReadSubStmt());
189 S->setElse(Reader.ReadSubStmt());
190 S->setIfLoc(ReadSourceLocation(Record, Idx));
191 S->setElseLoc(ReadSourceLocation(Record, Idx));
194 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
196 S->setConditionVariable(Reader.getContext(),
197 ReadDeclAs<VarDecl>(Record, Idx));
198 S->setCond(Reader.ReadSubExpr());
199 S->setBody(Reader.ReadSubStmt());
200 S->setSwitchLoc(ReadSourceLocation(Record, Idx));
202 S->setAllEnumCasesCovered();
204 SwitchCase *PrevSC = 0;
205 for (unsigned N = Record.size(); Idx != N; ++Idx) {
206 SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
208 PrevSC->setNextSwitchCase(SC);
210 S->setSwitchCaseList(SC);
216 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
218 S->setConditionVariable(Reader.getContext(),
219 ReadDeclAs<VarDecl>(Record, Idx));
221 S->setCond(Reader.ReadSubExpr());
222 S->setBody(Reader.ReadSubStmt());
223 S->setWhileLoc(ReadSourceLocation(Record, Idx));
226 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
228 S->setCond(Reader.ReadSubExpr());
229 S->setBody(Reader.ReadSubStmt());
230 S->setDoLoc(ReadSourceLocation(Record, Idx));
231 S->setWhileLoc(ReadSourceLocation(Record, Idx));
232 S->setRParenLoc(ReadSourceLocation(Record, Idx));
235 void ASTStmtReader::VisitForStmt(ForStmt *S) {
237 S->setInit(Reader.ReadSubStmt());
238 S->setCond(Reader.ReadSubExpr());
239 S->setConditionVariable(Reader.getContext(),
240 ReadDeclAs<VarDecl>(Record, Idx));
241 S->setInc(Reader.ReadSubExpr());
242 S->setBody(Reader.ReadSubStmt());
243 S->setForLoc(ReadSourceLocation(Record, Idx));
244 S->setLParenLoc(ReadSourceLocation(Record, Idx));
245 S->setRParenLoc(ReadSourceLocation(Record, Idx));
248 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
250 S->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
251 S->setGotoLoc(ReadSourceLocation(Record, Idx));
252 S->setLabelLoc(ReadSourceLocation(Record, Idx));
255 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
257 S->setGotoLoc(ReadSourceLocation(Record, Idx));
258 S->setStarLoc(ReadSourceLocation(Record, Idx));
259 S->setTarget(Reader.ReadSubExpr());
262 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
264 S->setContinueLoc(ReadSourceLocation(Record, Idx));
267 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
269 S->setBreakLoc(ReadSourceLocation(Record, Idx));
272 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
274 S->setRetValue(Reader.ReadSubExpr());
275 S->setReturnLoc(ReadSourceLocation(Record, Idx));
276 S->setNRVOCandidate(ReadDeclAs<VarDecl>(Record, Idx));
279 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
281 S->setStartLoc(ReadSourceLocation(Record, Idx));
282 S->setEndLoc(ReadSourceLocation(Record, Idx));
284 if (Idx + 1 == Record.size()) {
285 // Single declaration
286 S->setDeclGroup(DeclGroupRef(ReadDecl(Record, Idx)));
288 SmallVector<Decl *, 16> Decls;
289 Decls.reserve(Record.size() - Idx);
290 for (unsigned N = Record.size(); Idx != N; )
291 Decls.push_back(ReadDecl(Record, Idx));
292 S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Reader.getContext(),
298 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
300 S->NumOutputs = Record[Idx++];
301 S->NumInputs = Record[Idx++];
302 S->NumClobbers = Record[Idx++];
303 S->setAsmLoc(ReadSourceLocation(Record, Idx));
304 S->setVolatile(Record[Idx++]);
305 S->setSimple(Record[Idx++]);
308 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
310 S->setRParenLoc(ReadSourceLocation(Record, Idx));
311 S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
313 unsigned NumOutputs = S->getNumOutputs();
314 unsigned NumInputs = S->getNumInputs();
315 unsigned NumClobbers = S->getNumClobbers();
317 // Outputs and inputs
318 SmallVector<IdentifierInfo *, 16> Names;
319 SmallVector<StringLiteral*, 16> Constraints;
320 SmallVector<Stmt*, 16> Exprs;
321 for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
322 Names.push_back(Reader.GetIdentifierInfo(F, Record, Idx));
323 Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
324 Exprs.push_back(Reader.ReadSubStmt());
328 SmallVector<StringLiteral*, 16> Clobbers;
329 for (unsigned I = 0; I != NumClobbers; ++I)
330 Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
332 S->setOutputsAndInputsAndClobbers(Reader.getContext(),
333 Names.data(), Constraints.data(),
334 Exprs.data(), NumOutputs, NumInputs,
335 Clobbers.data(), NumClobbers);
338 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
340 S->LBraceLoc = ReadSourceLocation(Record, Idx);
341 S->EndLoc = ReadSourceLocation(Record, Idx);
342 S->NumAsmToks = Record[Idx++];
343 std::string AsmStr = ReadString(Record, Idx);
346 SmallVector<Token, 16> AsmToks;
347 AsmToks.reserve(S->NumAsmToks);
348 for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
349 AsmToks.push_back(ReadToken(Record, Idx));
352 // The calls to reserve() for the FooData vectors are mandatory to
353 // prevent dead StringRefs in the Foo vectors.
355 // Read the clobbers.
356 SmallVector<std::string, 16> ClobbersData;
357 SmallVector<StringRef, 16> Clobbers;
358 ClobbersData.reserve(S->NumClobbers);
359 Clobbers.reserve(S->NumClobbers);
360 for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
361 ClobbersData.push_back(ReadString(Record, Idx));
362 Clobbers.push_back(ClobbersData.back());
365 // Read the operands.
366 unsigned NumOperands = S->NumOutputs + S->NumInputs;
367 SmallVector<Expr*, 16> Exprs;
368 SmallVector<std::string, 16> ConstraintsData;
369 SmallVector<StringRef, 16> Constraints;
370 Exprs.reserve(NumOperands);
371 ConstraintsData.reserve(NumOperands);
372 Constraints.reserve(NumOperands);
373 for (unsigned i = 0; i != NumOperands; ++i) {
374 Exprs.push_back(cast<Expr>(Reader.ReadSubStmt()));
375 ConstraintsData.push_back(ReadString(Record, Idx));
376 Constraints.push_back(ConstraintsData.back());
379 S->initialize(Reader.getContext(), AsmStr, AsmToks,
380 Constraints, Exprs, Clobbers);
383 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
385 S->setCapturedDecl(ReadDeclAs<CapturedDecl>(Record, Idx));
386 S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record[Idx++]));
387 S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>(Record, Idx));
390 for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
391 E = S->capture_init_end();
393 *I = Reader.ReadSubExpr();
396 S->setCapturedStmt(Reader.ReadSubStmt());
397 S->getCapturedDecl()->setBody(S->getCapturedStmt());
400 for (CapturedStmt::capture_iterator I = S->capture_begin(),
401 E = S->capture_end();
403 I->VarAndKind.setPointer(ReadDeclAs<VarDecl>(Record, Idx));
405 .setInt(static_cast<CapturedStmt::VariableCaptureKind>(Record[Idx++]));
406 I->Loc = ReadSourceLocation(Record, Idx);
410 void ASTStmtReader::VisitExpr(Expr *E) {
412 E->setType(Reader.readType(F, Record, Idx));
413 E->setTypeDependent(Record[Idx++]);
414 E->setValueDependent(Record[Idx++]);
415 E->setInstantiationDependent(Record[Idx++]);
416 E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];
417 E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
418 E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
419 assert(Idx == NumExprFields && "Incorrect expression field count");
422 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
424 E->setLocation(ReadSourceLocation(Record, Idx));
425 E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
428 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
431 E->DeclRefExprBits.HasQualifier = Record[Idx++];
432 E->DeclRefExprBits.HasFoundDecl = Record[Idx++];
433 E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record[Idx++];
434 E->DeclRefExprBits.HadMultipleCandidates = Record[Idx++];
435 E->DeclRefExprBits.RefersToEnclosingLocal = Record[Idx++];
436 unsigned NumTemplateArgs = 0;
437 if (E->hasTemplateKWAndArgsInfo())
438 NumTemplateArgs = Record[Idx++];
440 if (E->hasQualifier())
441 E->getInternalQualifierLoc()
442 = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
444 if (E->hasFoundDecl())
445 E->getInternalFoundDecl() = ReadDeclAs<NamedDecl>(Record, Idx);
447 if (E->hasTemplateKWAndArgsInfo())
448 ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
451 E->setDecl(ReadDeclAs<ValueDecl>(Record, Idx));
452 E->setLocation(ReadSourceLocation(Record, Idx));
453 ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);
456 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
458 E->setLocation(ReadSourceLocation(Record, Idx));
459 E->setValue(Reader.getContext(), Reader.ReadAPInt(Record, Idx));
462 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
464 E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record[Idx++]));
465 E->setExact(Record[Idx++]);
466 E->setValue(Reader.getContext(),
467 Reader.ReadAPFloat(Record, E->getSemantics(), Idx));
468 E->setLocation(ReadSourceLocation(Record, Idx));
471 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
473 E->setSubExpr(Reader.ReadSubExpr());
476 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
478 unsigned Len = Record[Idx++];
479 assert(Record[Idx] == E->getNumConcatenated() &&
480 "Wrong number of concatenated tokens!");
482 StringLiteral::StringKind kind =
483 static_cast<StringLiteral::StringKind>(Record[Idx++]);
484 bool isPascal = Record[Idx++];
487 SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
488 E->setString(Reader.getContext(), Str.str(), kind, isPascal);
491 // Read source locations
492 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
493 E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));
496 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
498 E->setValue(Record[Idx++]);
499 E->setLocation(ReadSourceLocation(Record, Idx));
500 E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record[Idx++]));
503 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
505 E->setLParen(ReadSourceLocation(Record, Idx));
506 E->setRParen(ReadSourceLocation(Record, Idx));
507 E->setSubExpr(Reader.ReadSubExpr());
510 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
512 unsigned NumExprs = Record[Idx++];
513 E->Exprs = new (Reader.getContext()) Stmt*[NumExprs];
514 for (unsigned i = 0; i != NumExprs; ++i)
515 E->Exprs[i] = Reader.ReadSubStmt();
516 E->NumExprs = NumExprs;
517 E->LParenLoc = ReadSourceLocation(Record, Idx);
518 E->RParenLoc = ReadSourceLocation(Record, Idx);
521 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
523 E->setSubExpr(Reader.ReadSubExpr());
524 E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
525 E->setOperatorLoc(ReadSourceLocation(Record, Idx));
528 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
529 typedef OffsetOfExpr::OffsetOfNode Node;
531 assert(E->getNumComponents() == Record[Idx]);
533 assert(E->getNumExpressions() == Record[Idx]);
535 E->setOperatorLoc(ReadSourceLocation(Record, Idx));
536 E->setRParenLoc(ReadSourceLocation(Record, Idx));
537 E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
538 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
539 Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
540 SourceLocation Start = ReadSourceLocation(Record, Idx);
541 SourceLocation End = ReadSourceLocation(Record, Idx);
544 E->setComponent(I, Node(Start, Record[Idx++], End));
548 E->setComponent(I, Node(Start, ReadDeclAs<FieldDecl>(Record, Idx), End));
551 case Node::Identifier:
554 Reader.GetIdentifierInfo(F, Record, Idx),
559 CXXBaseSpecifier *Base = new (Reader.getContext()) CXXBaseSpecifier();
560 *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
561 E->setComponent(I, Node(Base));
567 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
568 E->setIndexExpr(I, Reader.ReadSubExpr());
571 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
573 E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++]));
574 if (Record[Idx] == 0) {
575 E->setArgument(Reader.ReadSubExpr());
578 E->setArgument(GetTypeSourceInfo(Record, Idx));
580 E->setOperatorLoc(ReadSourceLocation(Record, Idx));
581 E->setRParenLoc(ReadSourceLocation(Record, Idx));
584 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
586 E->setLHS(Reader.ReadSubExpr());
587 E->setRHS(Reader.ReadSubExpr());
588 E->setRBracketLoc(ReadSourceLocation(Record, Idx));
591 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
593 E->setNumArgs(Reader.getContext(), Record[Idx++]);
594 E->setRParenLoc(ReadSourceLocation(Record, Idx));
595 E->setCallee(Reader.ReadSubExpr());
596 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
597 E->setArg(I, Reader.ReadSubExpr());
600 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
604 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
605 // Don't call VisitExpr, this is fully initialized at creation.
606 assert(E->getStmtClass() == Stmt::MemberExprClass &&
607 "It's a subclass, we must advance Idx!");
610 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
612 E->setBase(Reader.ReadSubExpr());
613 E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));
614 E->setOpLoc(ReadSourceLocation(Record, Idx));
615 E->setArrow(Record[Idx++]);
619 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
621 E->Operand = Reader.ReadSubExpr();
622 E->setShouldCopy(Record[Idx++]);
625 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
626 VisitExplicitCastExpr(E);
627 E->LParenLoc = ReadSourceLocation(Record, Idx);
628 E->BridgeKeywordLoc = ReadSourceLocation(Record, Idx);
629 E->Kind = Record[Idx++];
632 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
634 unsigned NumBaseSpecs = Record[Idx++];
635 assert(NumBaseSpecs == E->path_size());
636 E->setSubExpr(Reader.ReadSubExpr());
637 E->setCastKind((CastExpr::CastKind)Record[Idx++]);
638 CastExpr::path_iterator BaseI = E->path_begin();
639 while (NumBaseSpecs--) {
640 CXXBaseSpecifier *BaseSpec = new (Reader.getContext()) CXXBaseSpecifier;
641 *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
646 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
648 E->setLHS(Reader.ReadSubExpr());
649 E->setRHS(Reader.ReadSubExpr());
650 E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
651 E->setOperatorLoc(ReadSourceLocation(Record, Idx));
652 E->setFPContractable((bool)Record[Idx++]);
655 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
656 VisitBinaryOperator(E);
657 E->setComputationLHSType(Reader.readType(F, Record, Idx));
658 E->setComputationResultType(Reader.readType(F, Record, Idx));
661 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
663 E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr();
664 E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr();
665 E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr();
666 E->QuestionLoc = ReadSourceLocation(Record, Idx);
667 E->ColonLoc = ReadSourceLocation(Record, Idx);
671 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
673 E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr());
674 E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr();
675 E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr();
676 E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr();
677 E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr();
678 E->QuestionLoc = ReadSourceLocation(Record, Idx);
679 E->ColonLoc = ReadSourceLocation(Record, Idx);
682 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
686 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
688 E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));
691 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
692 VisitExplicitCastExpr(E);
693 E->setLParenLoc(ReadSourceLocation(Record, Idx));
694 E->setRParenLoc(ReadSourceLocation(Record, Idx));
697 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
699 E->setLParenLoc(ReadSourceLocation(Record, Idx));
700 E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
701 E->setInitializer(Reader.ReadSubExpr());
702 E->setFileScope(Record[Idx++]);
705 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
707 E->setBase(Reader.ReadSubExpr());
708 E->setAccessor(Reader.GetIdentifierInfo(F, Record, Idx));
709 E->setAccessorLoc(ReadSourceLocation(Record, Idx));
712 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
714 if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Reader.ReadSubStmt()))
715 E->setSyntacticForm(SyntForm);
716 E->setLBraceLoc(ReadSourceLocation(Record, Idx));
717 E->setRBraceLoc(ReadSourceLocation(Record, Idx));
718 bool isArrayFiller = Record[Idx++];
721 filler = Reader.ReadSubExpr();
722 E->ArrayFillerOrUnionFieldInit = filler;
724 E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>(Record, Idx);
725 E->sawArrayRangeDesignator(Record[Idx++]);
726 E->setInitializesStdInitializerList(Record[Idx++]);
727 unsigned NumInits = Record[Idx++];
728 E->reserveInits(Reader.getContext(), NumInits);
730 for (unsigned I = 0; I != NumInits; ++I) {
731 Expr *init = Reader.ReadSubExpr();
732 E->updateInit(Reader.getContext(), I, init ? init : filler);
735 for (unsigned I = 0; I != NumInits; ++I)
736 E->updateInit(Reader.getContext(), I, Reader.ReadSubExpr());
740 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
741 typedef DesignatedInitExpr::Designator Designator;
744 unsigned NumSubExprs = Record[Idx++];
745 assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
746 for (unsigned I = 0; I != NumSubExprs; ++I)
747 E->setSubExpr(I, Reader.ReadSubExpr());
748 E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));
749 E->setGNUSyntax(Record[Idx++]);
751 SmallVector<Designator, 4> Designators;
752 while (Idx < Record.size()) {
753 switch ((DesignatorTypes)Record[Idx++]) {
754 case DESIG_FIELD_DECL: {
755 FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx);
756 SourceLocation DotLoc
757 = ReadSourceLocation(Record, Idx);
758 SourceLocation FieldLoc
759 = ReadSourceLocation(Record, Idx);
760 Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
762 Designators.back().setField(Field);
766 case DESIG_FIELD_NAME: {
767 const IdentifierInfo *Name = Reader.GetIdentifierInfo(F, Record, Idx);
768 SourceLocation DotLoc
769 = ReadSourceLocation(Record, Idx);
770 SourceLocation FieldLoc
771 = ReadSourceLocation(Record, Idx);
772 Designators.push_back(Designator(Name, DotLoc, FieldLoc));
777 unsigned Index = Record[Idx++];
778 SourceLocation LBracketLoc
779 = ReadSourceLocation(Record, Idx);
780 SourceLocation RBracketLoc
781 = ReadSourceLocation(Record, Idx);
782 Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
786 case DESIG_ARRAY_RANGE: {
787 unsigned Index = Record[Idx++];
788 SourceLocation LBracketLoc
789 = ReadSourceLocation(Record, Idx);
790 SourceLocation EllipsisLoc
791 = ReadSourceLocation(Record, Idx);
792 SourceLocation RBracketLoc
793 = ReadSourceLocation(Record, Idx);
794 Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
800 E->setDesignators(Reader.getContext(),
801 Designators.data(), Designators.size());
804 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
808 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
810 E->setSubExpr(Reader.ReadSubExpr());
811 E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));
812 E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
813 E->setRParenLoc(ReadSourceLocation(Record, Idx));
816 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
818 E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));
819 E->setLabelLoc(ReadSourceLocation(Record, Idx));
820 E->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
823 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
825 E->setLParenLoc(ReadSourceLocation(Record, Idx));
826 E->setRParenLoc(ReadSourceLocation(Record, Idx));
827 E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
830 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
832 E->setCond(Reader.ReadSubExpr());
833 E->setLHS(Reader.ReadSubExpr());
834 E->setRHS(Reader.ReadSubExpr());
835 E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
836 E->setRParenLoc(ReadSourceLocation(Record, Idx));
839 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
841 E->setTokenLocation(ReadSourceLocation(Record, Idx));
844 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
846 SmallVector<Expr *, 16> Exprs;
847 unsigned NumExprs = Record[Idx++];
849 Exprs.push_back(Reader.ReadSubExpr());
850 E->setExprs(Reader.getContext(), Exprs.data(), Exprs.size());
851 E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
852 E->setRParenLoc(ReadSourceLocation(Record, Idx));
855 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
857 E->setBlockDecl(ReadDeclAs<BlockDecl>(Record, Idx));
860 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
862 E->NumAssocs = Record[Idx++];
863 E->AssocTypes = new (Reader.getContext()) TypeSourceInfo*[E->NumAssocs];
865 new(Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
867 E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr();
868 for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
869 E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx);
870 E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr();
872 E->ResultIndex = Record[Idx++];
874 E->GenericLoc = ReadSourceLocation(Record, Idx);
875 E->DefaultLoc = ReadSourceLocation(Record, Idx);
876 E->RParenLoc = ReadSourceLocation(Record, Idx);
879 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
881 unsigned numSemanticExprs = Record[Idx++];
882 assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
883 E->PseudoObjectExprBits.ResultIndex = Record[Idx++];
885 // Read the syntactic expression.
886 E->getSubExprsBuffer()[0] = Reader.ReadSubExpr();
888 // Read all the semantic expressions.
889 for (unsigned i = 0; i != numSemanticExprs; ++i) {
890 Expr *subExpr = Reader.ReadSubExpr();
891 E->getSubExprsBuffer()[i+1] = subExpr;
895 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
897 E->Op = AtomicExpr::AtomicOp(Record[Idx++]);
898 E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
899 for (unsigned I = 0; I != E->NumSubExprs; ++I)
900 E->SubExprs[I] = Reader.ReadSubExpr();
901 E->BuiltinLoc = ReadSourceLocation(Record, Idx);
902 E->RParenLoc = ReadSourceLocation(Record, Idx);
905 //===----------------------------------------------------------------------===//
906 // Objective-C Expressions and Statements
908 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
910 E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
911 E->setAtLoc(ReadSourceLocation(Record, Idx));
914 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
916 // could be one of several IntegerLiteral, FloatLiteral, etc.
917 E->SubExpr = Reader.ReadSubStmt();
918 E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
919 E->Range = ReadSourceRange(Record, Idx);
922 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
924 unsigned NumElements = Record[Idx++];
925 assert(NumElements == E->getNumElements() && "Wrong number of elements");
926 Expr **Elements = E->getElements();
927 for (unsigned I = 0, N = NumElements; I != N; ++I)
928 Elements[I] = Reader.ReadSubExpr();
929 E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
930 E->Range = ReadSourceRange(Record, Idx);
933 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
935 unsigned NumElements = Record[Idx++];
936 assert(NumElements == E->getNumElements() && "Wrong number of elements");
937 bool HasPackExpansions = Record[Idx++];
938 assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
939 ObjCDictionaryLiteral::KeyValuePair *KeyValues = E->getKeyValues();
940 ObjCDictionaryLiteral::ExpansionData *Expansions = E->getExpansionData();
941 for (unsigned I = 0; I != NumElements; ++I) {
942 KeyValues[I].Key = Reader.ReadSubExpr();
943 KeyValues[I].Value = Reader.ReadSubExpr();
944 if (HasPackExpansions) {
945 Expansions[I].EllipsisLoc = ReadSourceLocation(Record, Idx);
946 Expansions[I].NumExpansionsPlusOne = Record[Idx++];
949 E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
950 E->Range = ReadSourceRange(Record, Idx);
953 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
955 E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
956 E->setAtLoc(ReadSourceLocation(Record, Idx));
957 E->setRParenLoc(ReadSourceLocation(Record, Idx));
960 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
962 E->setSelector(Reader.ReadSelector(F, Record, Idx));
963 E->setAtLoc(ReadSourceLocation(Record, Idx));
964 E->setRParenLoc(ReadSourceLocation(Record, Idx));
967 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
969 E->setProtocol(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
970 E->setAtLoc(ReadSourceLocation(Record, Idx));
971 E->ProtoLoc = ReadSourceLocation(Record, Idx);
972 E->setRParenLoc(ReadSourceLocation(Record, Idx));
975 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
977 E->setDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
978 E->setLocation(ReadSourceLocation(Record, Idx));
979 E->setOpLoc(ReadSourceLocation(Record, Idx));
980 E->setBase(Reader.ReadSubExpr());
981 E->setIsArrow(Record[Idx++]);
982 E->setIsFreeIvar(Record[Idx++]);
985 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
987 unsigned MethodRefFlags = Record[Idx++];
988 bool Implicit = Record[Idx++] != 0;
990 ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
991 ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
992 E->setImplicitProperty(Getter, Setter, MethodRefFlags);
994 E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(Record, Idx),
997 E->setLocation(ReadSourceLocation(Record, Idx));
998 E->setReceiverLocation(ReadSourceLocation(Record, Idx));
999 switch (Record[Idx++]) {
1001 E->setBase(Reader.ReadSubExpr());
1004 E->setSuperReceiver(Reader.readType(F, Record, Idx));
1007 E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1012 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1014 E->setRBracket(ReadSourceLocation(Record, Idx));
1015 E->setBaseExpr(Reader.ReadSubExpr());
1016 E->setKeyExpr(Reader.ReadSubExpr());
1017 E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1018 E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1021 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1023 assert(Record[Idx] == E->getNumArgs());
1025 unsigned NumStoredSelLocs = Record[Idx++];
1026 E->SelLocsKind = Record[Idx++];
1027 E->setDelegateInitCall(Record[Idx++]);
1028 E->IsImplicit = Record[Idx++];
1029 ObjCMessageExpr::ReceiverKind Kind
1030 = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
1032 case ObjCMessageExpr::Instance:
1033 E->setInstanceReceiver(Reader.ReadSubExpr());
1036 case ObjCMessageExpr::Class:
1037 E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
1040 case ObjCMessageExpr::SuperClass:
1041 case ObjCMessageExpr::SuperInstance: {
1042 QualType T = Reader.readType(F, Record, Idx);
1043 SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
1044 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1049 assert(Kind == E->getReceiverKind());
1052 E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
1054 E->setSelector(Reader.ReadSelector(F, Record, Idx));
1056 E->LBracLoc = ReadSourceLocation(Record, Idx);
1057 E->RBracLoc = ReadSourceLocation(Record, Idx);
1059 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1060 E->setArg(I, Reader.ReadSubExpr());
1062 SourceLocation *Locs = E->getStoredSelLocs();
1063 for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1064 Locs[I] = ReadSourceLocation(Record, Idx);
1067 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1069 S->setElement(Reader.ReadSubStmt());
1070 S->setCollection(Reader.ReadSubExpr());
1071 S->setBody(Reader.ReadSubStmt());
1072 S->setForLoc(ReadSourceLocation(Record, Idx));
1073 S->setRParenLoc(ReadSourceLocation(Record, Idx));
1076 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1078 S->setCatchBody(Reader.ReadSubStmt());
1079 S->setCatchParamDecl(ReadDeclAs<VarDecl>(Record, Idx));
1080 S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
1081 S->setRParenLoc(ReadSourceLocation(Record, Idx));
1084 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1086 S->setFinallyBody(Reader.ReadSubStmt());
1087 S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
1090 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1092 S->setSubStmt(Reader.ReadSubStmt());
1093 S->setAtLoc(ReadSourceLocation(Record, Idx));
1096 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1098 assert(Record[Idx] == S->getNumCatchStmts());
1100 bool HasFinally = Record[Idx++];
1101 S->setTryBody(Reader.ReadSubStmt());
1102 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1103 S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
1106 S->setFinallyStmt(Reader.ReadSubStmt());
1107 S->setAtTryLoc(ReadSourceLocation(Record, Idx));
1110 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1112 S->setSynchExpr(Reader.ReadSubStmt());
1113 S->setSynchBody(Reader.ReadSubStmt());
1114 S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
1117 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1119 S->setThrowExpr(Reader.ReadSubStmt());
1120 S->setThrowLoc(ReadSourceLocation(Record, Idx));
1123 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1125 E->setValue(Record[Idx++]);
1126 E->setLocation(ReadSourceLocation(Record, Idx));
1129 //===----------------------------------------------------------------------===//
1130 // C++ Expressions and Statements
1131 //===----------------------------------------------------------------------===//
1133 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1135 S->CatchLoc = ReadSourceLocation(Record, Idx);
1136 S->ExceptionDecl = ReadDeclAs<VarDecl>(Record, Idx);
1137 S->HandlerBlock = Reader.ReadSubStmt();
1140 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1142 assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
1144 S->TryLoc = ReadSourceLocation(Record, Idx);
1145 S->getStmts()[0] = Reader.ReadSubStmt();
1146 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1147 S->getStmts()[i + 1] = Reader.ReadSubStmt();
1150 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1152 S->setForLoc(ReadSourceLocation(Record, Idx));
1153 S->setColonLoc(ReadSourceLocation(Record, Idx));
1154 S->setRParenLoc(ReadSourceLocation(Record, Idx));
1155 S->setRangeStmt(Reader.ReadSubStmt());
1156 S->setBeginEndStmt(Reader.ReadSubStmt());
1157 S->setCond(Reader.ReadSubExpr());
1158 S->setInc(Reader.ReadSubExpr());
1159 S->setLoopVarStmt(Reader.ReadSubStmt());
1160 S->setBody(Reader.ReadSubStmt());
1163 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1165 S->KeywordLoc = ReadSourceLocation(Record, Idx);
1166 S->IsIfExists = Record[Idx++];
1167 S->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1168 ReadDeclarationNameInfo(S->NameInfo, Record, Idx);
1169 S->SubStmt = Reader.ReadSubStmt();
1172 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1174 E->Operator = (OverloadedOperatorKind)Record[Idx++];
1175 E->Range = Reader.ReadSourceRange(F, Record, Idx);
1176 E->setFPContractable((bool)Record[Idx++]);
1179 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1181 E->NumArgs = Record[Idx++];
1183 E->Args = new (Reader.getContext()) Stmt*[E->NumArgs];
1184 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1185 E->setArg(I, Reader.ReadSubExpr());
1186 E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx));
1187 E->setLocation(ReadSourceLocation(Record, Idx));
1188 E->setElidable(Record[Idx++]);
1189 E->setHadMultipleCandidates(Record[Idx++]);
1190 E->setListInitialization(Record[Idx++]);
1191 E->setRequiresZeroInitialization(Record[Idx++]);
1192 E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
1193 E->ParenRange = ReadSourceRange(Record, Idx);
1196 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1197 VisitCXXConstructExpr(E);
1198 E->Type = GetTypeSourceInfo(Record, Idx);
1201 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1203 unsigned NumCaptures = Record[Idx++];
1204 assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
1205 unsigned NumArrayIndexVars = Record[Idx++];
1206 E->IntroducerRange = ReadSourceRange(Record, Idx);
1207 E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record[Idx++]);
1208 E->ExplicitParams = Record[Idx++];
1209 E->ExplicitResultType = Record[Idx++];
1210 E->ClosingBrace = ReadSourceLocation(Record, Idx);
1212 // Read capture initializers.
1213 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1214 CEnd = E->capture_init_end();
1216 *C = Reader.ReadSubExpr();
1218 // Read array capture index variables.
1219 if (NumArrayIndexVars > 0) {
1220 unsigned *ArrayIndexStarts = E->getArrayIndexStarts();
1221 for (unsigned I = 0; I != NumCaptures + 1; ++I)
1222 ArrayIndexStarts[I] = Record[Idx++];
1224 VarDecl **ArrayIndexVars = E->getArrayIndexVars();
1225 for (unsigned I = 0; I != NumArrayIndexVars; ++I)
1226 ArrayIndexVars[I] = ReadDeclAs<VarDecl>(Record, Idx);
1230 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1231 VisitExplicitCastExpr(E);
1232 SourceRange R = ReadSourceRange(Record, Idx);
1233 E->Loc = R.getBegin();
1234 E->RParenLoc = R.getEnd();
1235 R = ReadSourceRange(Record, Idx);
1236 E->AngleBrackets = R;
1239 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1240 return VisitCXXNamedCastExpr(E);
1243 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1244 return VisitCXXNamedCastExpr(E);
1247 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1248 return VisitCXXNamedCastExpr(E);
1251 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1252 return VisitCXXNamedCastExpr(E);
1255 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1256 VisitExplicitCastExpr(E);
1257 E->setTypeBeginLoc(ReadSourceLocation(Record, Idx));
1258 E->setRParenLoc(ReadSourceLocation(Record, Idx));
1261 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1263 E->UDSuffixLoc = ReadSourceLocation(Record, Idx);
1266 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1268 E->setValue(Record[Idx++]);
1269 E->setLocation(ReadSourceLocation(Record, Idx));
1272 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1274 E->setLocation(ReadSourceLocation(Record, Idx));
1277 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1279 E->setSourceRange(ReadSourceRange(Record, Idx));
1280 if (E->isTypeOperand()) { // typeid(int)
1281 E->setTypeOperandSourceInfo(
1282 GetTypeSourceInfo(Record, Idx));
1287 E->setExprOperand(Reader.ReadSubExpr());
1290 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1292 E->setLocation(ReadSourceLocation(Record, Idx));
1293 E->setImplicit(Record[Idx++]);
1296 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1298 E->ThrowLoc = ReadSourceLocation(Record, Idx);
1299 E->Op = Reader.ReadSubExpr();
1300 E->IsThrownVariableInScope = Record[Idx++];
1303 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1306 assert((bool)Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1307 ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1308 E->Param.setPointer(ReadDeclAs<ParmVarDecl>(Record, Idx));
1309 E->Loc = ReadSourceLocation(Record, Idx);
1312 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1314 E->Field = ReadDeclAs<FieldDecl>(Record, Idx);
1315 E->Loc = ReadSourceLocation(Record, Idx);
1318 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1320 E->setTemporary(Reader.ReadCXXTemporary(F, Record, Idx));
1321 E->setSubExpr(Reader.ReadSubExpr());
1324 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1326 E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1327 E->RParenLoc = ReadSourceLocation(Record, Idx);
1330 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1332 E->GlobalNew = Record[Idx++];
1333 bool isArray = Record[Idx++];
1334 E->UsualArrayDeleteWantsSize = Record[Idx++];
1335 unsigned NumPlacementArgs = Record[Idx++];
1336 E->StoredInitializationStyle = Record[Idx++];
1337 E->setOperatorNew(ReadDeclAs<FunctionDecl>(Record, Idx));
1338 E->setOperatorDelete(ReadDeclAs<FunctionDecl>(Record, Idx));
1339 E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1340 E->TypeIdParens = ReadSourceRange(Record, Idx);
1341 E->Range = ReadSourceRange(Record, Idx);
1342 E->DirectInitRange = ReadSourceRange(Record, Idx);
1344 E->AllocateArgsArray(Reader.getContext(), isArray, NumPlacementArgs,
1345 E->StoredInitializationStyle != 0);
1347 // Install all the subexpressions.
1348 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1350 *I = Reader.ReadSubStmt();
1353 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1355 E->GlobalDelete = Record[Idx++];
1356 E->ArrayForm = Record[Idx++];
1357 E->ArrayFormAsWritten = Record[Idx++];
1358 E->UsualArrayDeleteWantsSize = Record[Idx++];
1359 E->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1360 E->Argument = Reader.ReadSubExpr();
1361 E->Loc = ReadSourceLocation(Record, Idx);
1364 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1367 E->Base = Reader.ReadSubExpr();
1368 E->IsArrow = Record[Idx++];
1369 E->OperatorLoc = ReadSourceLocation(Record, Idx);
1370 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1371 E->ScopeType = GetTypeSourceInfo(Record, Idx);
1372 E->ColonColonLoc = ReadSourceLocation(Record, Idx);
1373 E->TildeLoc = ReadSourceLocation(Record, Idx);
1375 IdentifierInfo *II = Reader.GetIdentifierInfo(F, Record, Idx);
1377 E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1379 E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1382 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1385 unsigned NumObjects = Record[Idx++];
1386 assert(NumObjects == E->getNumObjects());
1387 for (unsigned i = 0; i != NumObjects; ++i)
1388 E->getObjectsBuffer()[i] = ReadDeclAs<BlockDecl>(Record, Idx);
1390 E->SubExpr = Reader.ReadSubExpr();
1394 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1397 if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1398 ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
1399 /*NumTemplateArgs=*/Record[Idx++]);
1401 E->Base = Reader.ReadSubExpr();
1402 E->BaseType = Reader.readType(F, Record, Idx);
1403 E->IsArrow = Record[Idx++];
1404 E->OperatorLoc = ReadSourceLocation(Record, Idx);
1405 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1406 E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(Record, Idx);
1407 ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1411 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1414 if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1415 ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
1416 /*NumTemplateArgs=*/Record[Idx++]);
1418 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1419 ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1423 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1425 assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1427 for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1428 E->setArg(I, Reader.ReadSubExpr());
1429 E->Type = GetTypeSourceInfo(Record, Idx);
1430 E->setLParenLoc(ReadSourceLocation(Record, Idx));
1431 E->setRParenLoc(ReadSourceLocation(Record, Idx));
1434 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1437 if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1438 ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
1439 /*NumTemplateArgs=*/Record[Idx++]);
1441 unsigned NumDecls = Record[Idx++];
1442 UnresolvedSet<8> Decls;
1443 for (unsigned i = 0; i != NumDecls; ++i) {
1444 NamedDecl *D = ReadDeclAs<NamedDecl>(Record, Idx);
1445 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1446 Decls.addDecl(D, AS);
1448 E->initializeResults(Reader.getContext(), Decls.begin(), Decls.end());
1450 ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1451 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1454 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1455 VisitOverloadExpr(E);
1456 E->IsArrow = Record[Idx++];
1457 E->HasUnresolvedUsing = Record[Idx++];
1458 E->Base = Reader.ReadSubExpr();
1459 E->BaseType = Reader.readType(F, Record, Idx);
1460 E->OperatorLoc = ReadSourceLocation(Record, Idx);
1463 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1464 VisitOverloadExpr(E);
1465 E->RequiresADL = Record[Idx++];
1466 E->Overloaded = Record[Idx++];
1467 E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1470 void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1472 E->UTT = (UnaryTypeTrait)Record[Idx++];
1473 E->Value = (bool)Record[Idx++];
1474 SourceRange Range = ReadSourceRange(Record, Idx);
1475 E->Loc = Range.getBegin();
1476 E->RParen = Range.getEnd();
1477 E->QueriedType = GetTypeSourceInfo(Record, Idx);
1480 void ASTStmtReader::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1482 E->BTT = (BinaryTypeTrait)Record[Idx++];
1483 E->Value = (bool)Record[Idx++];
1484 SourceRange Range = ReadSourceRange(Record, Idx);
1485 E->Loc = Range.getBegin();
1486 E->RParen = Range.getEnd();
1487 E->LhsType = GetTypeSourceInfo(Record, Idx);
1488 E->RhsType = GetTypeSourceInfo(Record, Idx);
1491 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
1493 E->TypeTraitExprBits.NumArgs = Record[Idx++];
1494 E->TypeTraitExprBits.Kind = Record[Idx++];
1495 E->TypeTraitExprBits.Value = Record[Idx++];
1497 TypeSourceInfo **Args = E->getTypeSourceInfos();
1498 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1499 Args[I] = GetTypeSourceInfo(Record, Idx);
1502 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1504 E->ATT = (ArrayTypeTrait)Record[Idx++];
1505 E->Value = (unsigned int)Record[Idx++];
1506 SourceRange Range = ReadSourceRange(Record, Idx);
1507 E->Loc = Range.getBegin();
1508 E->RParen = Range.getEnd();
1509 E->QueriedType = GetTypeSourceInfo(Record, Idx);
1512 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1514 E->ET = (ExpressionTrait)Record[Idx++];
1515 E->Value = (bool)Record[Idx++];
1516 SourceRange Range = ReadSourceRange(Record, Idx);
1517 E->QueriedExpression = Reader.ReadSubExpr();
1518 E->Loc = Range.getBegin();
1519 E->RParen = Range.getEnd();
1522 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1524 E->Value = (bool)Record[Idx++];
1525 E->Range = ReadSourceRange(Record, Idx);
1526 E->Operand = Reader.ReadSubExpr();
1529 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1531 E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1532 E->NumExpansions = Record[Idx++];
1533 E->Pattern = Reader.ReadSubExpr();
1536 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1538 E->OperatorLoc = ReadSourceLocation(Record, Idx);
1539 E->PackLoc = ReadSourceLocation(Record, Idx);
1540 E->RParenLoc = ReadSourceLocation(Record, Idx);
1541 E->Length = Record[Idx++];
1542 E->Pack = ReadDeclAs<NamedDecl>(Record, Idx);
1545 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1546 SubstNonTypeTemplateParmExpr *E) {
1548 E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1549 E->NameLoc = ReadSourceLocation(Record, Idx);
1550 E->Replacement = Reader.ReadSubExpr();
1553 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1554 SubstNonTypeTemplateParmPackExpr *E) {
1556 E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1557 TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);
1558 if (ArgPack.getKind() != TemplateArgument::Pack)
1561 E->Arguments = ArgPack.pack_begin();
1562 E->NumArguments = ArgPack.pack_size();
1563 E->NameLoc = ReadSourceLocation(Record, Idx);
1566 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1568 E->NumParameters = Record[Idx++];
1569 E->ParamPack = ReadDeclAs<ParmVarDecl>(Record, Idx);
1570 E->NameLoc = ReadSourceLocation(Record, Idx);
1571 ParmVarDecl **Parms = reinterpret_cast<ParmVarDecl**>(E+1);
1572 for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
1573 Parms[i] = ReadDeclAs<ParmVarDecl>(Record, Idx);
1576 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1578 E->Temporary = Reader.ReadSubExpr();
1581 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1583 E->SourceExpr = Reader.ReadSubExpr();
1584 E->Loc = ReadSourceLocation(Record, Idx);
1587 //===----------------------------------------------------------------------===//
1588 // Microsoft Expressions and Statements
1589 //===----------------------------------------------------------------------===//
1590 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1592 E->IsArrow = (Record[Idx++] != 0);
1593 E->BaseExpr = Reader.ReadSubExpr();
1594 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1595 E->MemberLoc = ReadSourceLocation(Record, Idx);
1596 E->TheDecl = ReadDeclAs<MSPropertyDecl>(Record, Idx);
1599 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1601 E->setSourceRange(ReadSourceRange(Record, Idx));
1602 if (E->isTypeOperand()) { // __uuidof(ComType)
1603 E->setTypeOperandSourceInfo(
1604 GetTypeSourceInfo(Record, Idx));
1609 E->setExprOperand(Reader.ReadSubExpr());
1612 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1614 S->Loc = ReadSourceLocation(Record, Idx);
1615 S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt();
1616 S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt();
1619 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1621 S->Loc = ReadSourceLocation(Record, Idx);
1622 S->Block = Reader.ReadSubStmt();
1625 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1627 S->IsCXXTry = Record[Idx++];
1628 S->TryLoc = ReadSourceLocation(Record, Idx);
1629 S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt();
1630 S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt();
1633 //===----------------------------------------------------------------------===//
1634 // CUDA Expressions and Statements
1635 //===----------------------------------------------------------------------===//
1637 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1639 E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));
1642 //===----------------------------------------------------------------------===//
1643 // OpenCL Expressions and Statements.
1644 //===----------------------------------------------------------------------===//
1645 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1647 E->BuiltinLoc = ReadSourceLocation(Record, Idx);
1648 E->RParenLoc = ReadSourceLocation(Record, Idx);
1649 E->SrcExpr = Reader.ReadSubExpr();
1652 //===----------------------------------------------------------------------===//
1653 // ASTReader Implementation
1654 //===----------------------------------------------------------------------===//
1656 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
1657 switch (ReadingKind) {
1660 return ReadStmtFromStream(F);
1662 return ReadSubStmt();
1665 llvm_unreachable("ReadingKind not set ?");
1668 Expr *ASTReader::ReadExpr(ModuleFile &F) {
1669 return cast_or_null<Expr>(ReadStmt(F));
1672 Expr *ASTReader::ReadSubExpr() {
1673 return cast_or_null<Expr>(ReadSubStmt());
1676 // Within the bitstream, expressions are stored in Reverse Polish
1677 // Notation, with each of the subexpressions preceding the
1678 // expression they are stored in. Subexpressions are stored from last to first.
1679 // To evaluate expressions, we continue reading expressions and placing them on
1680 // the stack, with expressions having operands removing those operands from the
1681 // stack. Evaluation terminates when we see a STMT_STOP record, and
1682 // the single remaining expression on the stack is our result.
1683 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
1685 ReadingKindTracker ReadingKind(Read_Stmt, *this);
1686 llvm::BitstreamCursor &Cursor = F.DeclsCursor;
1688 // Map of offset to previously deserialized stmt. The offset points
1689 /// just after the stmt record.
1690 llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
1693 unsigned PrevNumStmts = StmtStack.size();
1698 ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
1699 Stmt::EmptyShell Empty;
1702 llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();
1704 switch (Entry.Kind) {
1705 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1706 case llvm::BitstreamEntry::Error:
1707 Error("malformed block record in AST file");
1709 case llvm::BitstreamEntry::EndBlock:
1711 case llvm::BitstreamEntry::Record:
1712 // The interesting case.
1720 bool Finished = false;
1721 bool IsStmtReference = false;
1722 switch ((StmtCode)Cursor.readRecord(Entry.ID, Record)) {
1728 IsStmtReference = true;
1729 assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
1730 "No stmt was recorded for this offset reference!");
1731 S = StmtEntries[Record[Idx++]];
1739 S = new (Context) NullStmt(Empty);
1743 S = new (Context) CompoundStmt(Empty);
1747 S = new (Context) CaseStmt(Empty);
1751 S = new (Context) DefaultStmt(Empty);
1755 S = new (Context) LabelStmt(Empty);
1758 case STMT_ATTRIBUTED:
1759 S = AttributedStmt::CreateEmpty(
1761 /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
1765 S = new (Context) IfStmt(Empty);
1769 S = new (Context) SwitchStmt(Empty);
1773 S = new (Context) WhileStmt(Empty);
1777 S = new (Context) DoStmt(Empty);
1781 S = new (Context) ForStmt(Empty);
1785 S = new (Context) GotoStmt(Empty);
1788 case STMT_INDIRECT_GOTO:
1789 S = new (Context) IndirectGotoStmt(Empty);
1793 S = new (Context) ContinueStmt(Empty);
1797 S = new (Context) BreakStmt(Empty);
1801 S = new (Context) ReturnStmt(Empty);
1805 S = new (Context) DeclStmt(Empty);
1809 S = new (Context) GCCAsmStmt(Empty);
1813 S = new (Context) MSAsmStmt(Empty);
1817 S = CapturedStmt::CreateDeserialized(Context,
1818 Record[ASTStmtReader::NumExprFields]);
1821 case EXPR_PREDEFINED:
1822 S = new (Context) PredefinedExpr(Empty);
1826 S = DeclRefExpr::CreateEmpty(
1828 /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
1829 /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
1830 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
1831 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
1832 Record[ASTStmtReader::NumExprFields + 5] : 0);
1835 case EXPR_INTEGER_LITERAL:
1836 S = IntegerLiteral::Create(Context, Empty);
1839 case EXPR_FLOATING_LITERAL:
1840 S = FloatingLiteral::Create(Context, Empty);
1843 case EXPR_IMAGINARY_LITERAL:
1844 S = new (Context) ImaginaryLiteral(Empty);
1847 case EXPR_STRING_LITERAL:
1848 S = StringLiteral::CreateEmpty(Context,
1849 Record[ASTStmtReader::NumExprFields + 1]);
1852 case EXPR_CHARACTER_LITERAL:
1853 S = new (Context) CharacterLiteral(Empty);
1857 S = new (Context) ParenExpr(Empty);
1860 case EXPR_PAREN_LIST:
1861 S = new (Context) ParenListExpr(Empty);
1864 case EXPR_UNARY_OPERATOR:
1865 S = new (Context) UnaryOperator(Empty);
1869 S = OffsetOfExpr::CreateEmpty(Context,
1870 Record[ASTStmtReader::NumExprFields],
1871 Record[ASTStmtReader::NumExprFields + 1]);
1874 case EXPR_SIZEOF_ALIGN_OF:
1875 S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
1878 case EXPR_ARRAY_SUBSCRIPT:
1879 S = new (Context) ArraySubscriptExpr(Empty);
1883 S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
1887 // We load everything here and fully initialize it at creation.
1888 // That way we can use MemberExpr::Create and don't have to duplicate its
1889 // logic with a MemberExpr::CreateEmpty.
1892 NestedNameSpecifierLoc QualifierLoc;
1893 if (Record[Idx++]) { // HasQualifier.
1894 QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
1897 SourceLocation TemplateKWLoc;
1898 TemplateArgumentListInfo ArgInfo;
1899 bool HasTemplateKWAndArgsInfo = Record[Idx++];
1900 if (HasTemplateKWAndArgsInfo) {
1901 TemplateKWLoc = ReadSourceLocation(F, Record, Idx);
1902 unsigned NumTemplateArgs = Record[Idx++];
1903 ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
1904 ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
1905 for (unsigned i = 0; i != NumTemplateArgs; ++i)
1906 ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
1909 bool HadMultipleCandidates = Record[Idx++];
1911 NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx);
1912 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1913 DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
1915 QualType T = readType(F, Record, Idx);
1916 ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
1917 ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
1918 Expr *Base = ReadSubExpr();
1919 ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx);
1920 SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
1921 DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
1922 bool IsArrow = Record[Idx++];
1924 S = MemberExpr::Create(Context, Base, IsArrow, QualifierLoc,
1925 TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
1926 HasTemplateKWAndArgsInfo ? &ArgInfo : 0,
1928 ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
1929 MemberD->getDeclName(), Record, Idx);
1930 if (HadMultipleCandidates)
1931 cast<MemberExpr>(S)->setHadMultipleCandidates(true);
1935 case EXPR_BINARY_OPERATOR:
1936 S = new (Context) BinaryOperator(Empty);
1939 case EXPR_COMPOUND_ASSIGN_OPERATOR:
1940 S = new (Context) CompoundAssignOperator(Empty);
1943 case EXPR_CONDITIONAL_OPERATOR:
1944 S = new (Context) ConditionalOperator(Empty);
1947 case EXPR_BINARY_CONDITIONAL_OPERATOR:
1948 S = new (Context) BinaryConditionalOperator(Empty);
1951 case EXPR_IMPLICIT_CAST:
1952 S = ImplicitCastExpr::CreateEmpty(Context,
1953 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1956 case EXPR_CSTYLE_CAST:
1957 S = CStyleCastExpr::CreateEmpty(Context,
1958 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1961 case EXPR_COMPOUND_LITERAL:
1962 S = new (Context) CompoundLiteralExpr(Empty);
1965 case EXPR_EXT_VECTOR_ELEMENT:
1966 S = new (Context) ExtVectorElementExpr(Empty);
1969 case EXPR_INIT_LIST:
1970 S = new (Context) InitListExpr(Empty);
1973 case EXPR_DESIGNATED_INIT:
1974 S = DesignatedInitExpr::CreateEmpty(Context,
1975 Record[ASTStmtReader::NumExprFields] - 1);
1979 case EXPR_IMPLICIT_VALUE_INIT:
1980 S = new (Context) ImplicitValueInitExpr(Empty);
1984 S = new (Context) VAArgExpr(Empty);
1987 case EXPR_ADDR_LABEL:
1988 S = new (Context) AddrLabelExpr(Empty);
1992 S = new (Context) StmtExpr(Empty);
1996 S = new (Context) ChooseExpr(Empty);
2000 S = new (Context) GNUNullExpr(Empty);
2003 case EXPR_SHUFFLE_VECTOR:
2004 S = new (Context) ShuffleVectorExpr(Empty);
2008 S = new (Context) BlockExpr(Empty);
2011 case EXPR_GENERIC_SELECTION:
2012 S = new (Context) GenericSelectionExpr(Empty);
2015 case EXPR_OBJC_STRING_LITERAL:
2016 S = new (Context) ObjCStringLiteral(Empty);
2018 case EXPR_OBJC_BOXED_EXPRESSION:
2019 S = new (Context) ObjCBoxedExpr(Empty);
2021 case EXPR_OBJC_ARRAY_LITERAL:
2022 S = ObjCArrayLiteral::CreateEmpty(Context,
2023 Record[ASTStmtReader::NumExprFields]);
2025 case EXPR_OBJC_DICTIONARY_LITERAL:
2026 S = ObjCDictionaryLiteral::CreateEmpty(Context,
2027 Record[ASTStmtReader::NumExprFields],
2028 Record[ASTStmtReader::NumExprFields + 1]);
2030 case EXPR_OBJC_ENCODE:
2031 S = new (Context) ObjCEncodeExpr(Empty);
2033 case EXPR_OBJC_SELECTOR_EXPR:
2034 S = new (Context) ObjCSelectorExpr(Empty);
2036 case EXPR_OBJC_PROTOCOL_EXPR:
2037 S = new (Context) ObjCProtocolExpr(Empty);
2039 case EXPR_OBJC_IVAR_REF_EXPR:
2040 S = new (Context) ObjCIvarRefExpr(Empty);
2042 case EXPR_OBJC_PROPERTY_REF_EXPR:
2043 S = new (Context) ObjCPropertyRefExpr(Empty);
2045 case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
2046 S = new (Context) ObjCSubscriptRefExpr(Empty);
2048 case EXPR_OBJC_KVC_REF_EXPR:
2049 llvm_unreachable("mismatching AST file");
2050 case EXPR_OBJC_MESSAGE_EXPR:
2051 S = ObjCMessageExpr::CreateEmpty(Context,
2052 Record[ASTStmtReader::NumExprFields],
2053 Record[ASTStmtReader::NumExprFields + 1]);
2056 S = new (Context) ObjCIsaExpr(Empty);
2058 case EXPR_OBJC_INDIRECT_COPY_RESTORE:
2059 S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
2061 case EXPR_OBJC_BRIDGED_CAST:
2062 S = new (Context) ObjCBridgedCastExpr(Empty);
2064 case STMT_OBJC_FOR_COLLECTION:
2065 S = new (Context) ObjCForCollectionStmt(Empty);
2067 case STMT_OBJC_CATCH:
2068 S = new (Context) ObjCAtCatchStmt(Empty);
2070 case STMT_OBJC_FINALLY:
2071 S = new (Context) ObjCAtFinallyStmt(Empty);
2073 case STMT_OBJC_AT_TRY:
2074 S = ObjCAtTryStmt::CreateEmpty(Context,
2075 Record[ASTStmtReader::NumStmtFields],
2076 Record[ASTStmtReader::NumStmtFields + 1]);
2078 case STMT_OBJC_AT_SYNCHRONIZED:
2079 S = new (Context) ObjCAtSynchronizedStmt(Empty);
2081 case STMT_OBJC_AT_THROW:
2082 S = new (Context) ObjCAtThrowStmt(Empty);
2084 case STMT_OBJC_AUTORELEASE_POOL:
2085 S = new (Context) ObjCAutoreleasePoolStmt(Empty);
2087 case EXPR_OBJC_BOOL_LITERAL:
2088 S = new (Context) ObjCBoolLiteralExpr(Empty);
2090 case STMT_SEH_EXCEPT:
2091 S = new (Context) SEHExceptStmt(Empty);
2093 case STMT_SEH_FINALLY:
2094 S = new (Context) SEHFinallyStmt(Empty);
2097 S = new (Context) SEHTryStmt(Empty);
2099 case STMT_CXX_CATCH:
2100 S = new (Context) CXXCatchStmt(Empty);
2104 S = CXXTryStmt::Create(Context, Empty,
2105 /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
2108 case STMT_CXX_FOR_RANGE:
2109 S = new (Context) CXXForRangeStmt(Empty);
2112 case STMT_MS_DEPENDENT_EXISTS:
2113 S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
2114 NestedNameSpecifierLoc(),
2115 DeclarationNameInfo(),
2119 case EXPR_CXX_OPERATOR_CALL:
2120 S = new (Context) CXXOperatorCallExpr(Context, Empty);
2123 case EXPR_CXX_MEMBER_CALL:
2124 S = new (Context) CXXMemberCallExpr(Context, Empty);
2127 case EXPR_CXX_CONSTRUCT:
2128 S = new (Context) CXXConstructExpr(Empty);
2131 case EXPR_CXX_TEMPORARY_OBJECT:
2132 S = new (Context) CXXTemporaryObjectExpr(Empty);
2135 case EXPR_CXX_STATIC_CAST:
2136 S = CXXStaticCastExpr::CreateEmpty(Context,
2137 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2140 case EXPR_CXX_DYNAMIC_CAST:
2141 S = CXXDynamicCastExpr::CreateEmpty(Context,
2142 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2145 case EXPR_CXX_REINTERPRET_CAST:
2146 S = CXXReinterpretCastExpr::CreateEmpty(Context,
2147 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2150 case EXPR_CXX_CONST_CAST:
2151 S = CXXConstCastExpr::CreateEmpty(Context);
2154 case EXPR_CXX_FUNCTIONAL_CAST:
2155 S = CXXFunctionalCastExpr::CreateEmpty(Context,
2156 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2159 case EXPR_USER_DEFINED_LITERAL:
2160 S = new (Context) UserDefinedLiteral(Context, Empty);
2163 case EXPR_CXX_BOOL_LITERAL:
2164 S = new (Context) CXXBoolLiteralExpr(Empty);
2167 case EXPR_CXX_NULL_PTR_LITERAL:
2168 S = new (Context) CXXNullPtrLiteralExpr(Empty);
2170 case EXPR_CXX_TYPEID_EXPR:
2171 S = new (Context) CXXTypeidExpr(Empty, true);
2173 case EXPR_CXX_TYPEID_TYPE:
2174 S = new (Context) CXXTypeidExpr(Empty, false);
2176 case EXPR_CXX_UUIDOF_EXPR:
2177 S = new (Context) CXXUuidofExpr(Empty, true);
2179 case EXPR_CXX_PROPERTY_REF_EXPR:
2180 S = new (Context) MSPropertyRefExpr(Empty);
2182 case EXPR_CXX_UUIDOF_TYPE:
2183 S = new (Context) CXXUuidofExpr(Empty, false);
2186 S = new (Context) CXXThisExpr(Empty);
2188 case EXPR_CXX_THROW:
2189 S = new (Context) CXXThrowExpr(Empty);
2191 case EXPR_CXX_DEFAULT_ARG: {
2192 bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
2193 if (HasOtherExprStored) {
2194 Expr *SubExpr = ReadSubExpr();
2195 S = CXXDefaultArgExpr::Create(Context, SourceLocation(), 0, SubExpr);
2197 S = new (Context) CXXDefaultArgExpr(Empty);
2200 case EXPR_CXX_DEFAULT_INIT:
2201 S = new (Context) CXXDefaultInitExpr(Empty);
2203 case EXPR_CXX_BIND_TEMPORARY:
2204 S = new (Context) CXXBindTemporaryExpr(Empty);
2207 case EXPR_CXX_SCALAR_VALUE_INIT:
2208 S = new (Context) CXXScalarValueInitExpr(Empty);
2211 S = new (Context) CXXNewExpr(Empty);
2213 case EXPR_CXX_DELETE:
2214 S = new (Context) CXXDeleteExpr(Empty);
2216 case EXPR_CXX_PSEUDO_DESTRUCTOR:
2217 S = new (Context) CXXPseudoDestructorExpr(Empty);
2220 case EXPR_EXPR_WITH_CLEANUPS:
2221 S = ExprWithCleanups::Create(Context, Empty,
2222 Record[ASTStmtReader::NumExprFields]);
2225 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
2226 S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
2227 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2228 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2229 ? Record[ASTStmtReader::NumExprFields + 1]
2233 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
2234 S = DependentScopeDeclRefExpr::CreateEmpty(Context,
2235 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2236 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2237 ? Record[ASTStmtReader::NumExprFields + 1]
2241 case EXPR_CXX_UNRESOLVED_CONSTRUCT:
2242 S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
2243 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
2246 case EXPR_CXX_UNRESOLVED_MEMBER:
2247 S = UnresolvedMemberExpr::CreateEmpty(Context,
2248 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2249 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2250 ? Record[ASTStmtReader::NumExprFields + 1]
2254 case EXPR_CXX_UNRESOLVED_LOOKUP:
2255 S = UnresolvedLookupExpr::CreateEmpty(Context,
2256 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2257 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2258 ? Record[ASTStmtReader::NumExprFields + 1]
2262 case EXPR_CXX_UNARY_TYPE_TRAIT:
2263 S = new (Context) UnaryTypeTraitExpr(Empty);
2266 case EXPR_BINARY_TYPE_TRAIT:
2267 S = new (Context) BinaryTypeTraitExpr(Empty);
2270 case EXPR_TYPE_TRAIT:
2271 S = TypeTraitExpr::CreateDeserialized(Context,
2272 Record[ASTStmtReader::NumExprFields]);
2275 case EXPR_ARRAY_TYPE_TRAIT:
2276 S = new (Context) ArrayTypeTraitExpr(Empty);
2279 case EXPR_CXX_EXPRESSION_TRAIT:
2280 S = new (Context) ExpressionTraitExpr(Empty);
2283 case EXPR_CXX_NOEXCEPT:
2284 S = new (Context) CXXNoexceptExpr(Empty);
2287 case EXPR_PACK_EXPANSION:
2288 S = new (Context) PackExpansionExpr(Empty);
2291 case EXPR_SIZEOF_PACK:
2292 S = new (Context) SizeOfPackExpr(Empty);
2295 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
2296 S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
2299 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
2300 S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
2303 case EXPR_FUNCTION_PARM_PACK:
2304 S = FunctionParmPackExpr::CreateEmpty(Context,
2305 Record[ASTStmtReader::NumExprFields]);
2308 case EXPR_MATERIALIZE_TEMPORARY:
2309 S = new (Context) MaterializeTemporaryExpr(Empty);
2312 case EXPR_OPAQUE_VALUE:
2313 S = new (Context) OpaqueValueExpr(Empty);
2316 case EXPR_CUDA_KERNEL_CALL:
2317 S = new (Context) CUDAKernelCallExpr(Context, Empty);
2321 S = new (Context) AsTypeExpr(Empty);
2324 case EXPR_PSEUDO_OBJECT: {
2325 unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
2326 S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
2331 S = new (Context) AtomicExpr(Empty);
2335 unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
2336 unsigned NumArrayIndexVars = Record[ASTStmtReader::NumExprFields + 1];
2337 S = LambdaExpr::CreateDeserialized(Context, NumCaptures,
2343 // We hit a STMT_STOP, so we're done with this expression.
2347 ++NumStatementsRead;
2349 if (S && !IsStmtReference) {
2351 StmtEntries[Cursor.GetCurrentBitNo()] = S;
2355 assert(Idx == Record.size() && "Invalid deserialization of statement");
2356 StmtStack.push_back(S);
2359 assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!");
2360 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
2361 return StmtStack.pop_back_val();