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 friend class OMPClauseReader;
30 ASTRecordReader &Record;
31 llvm::BitstreamCursor &DeclsCursor;
33 SourceLocation ReadSourceLocation() {
34 return Record.readSourceLocation();
37 SourceRange ReadSourceRange() {
38 return Record.readSourceRange();
41 std::string ReadString() {
42 return Record.readString();
45 TypeSourceInfo *GetTypeSourceInfo() {
46 return Record.getTypeSourceInfo();
50 return Record.readDecl();
55 return Record.readDeclAs<T>();
58 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc,
59 DeclarationName Name) {
60 Record.readDeclarationNameLoc(DNLoc, Name);
63 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo) {
64 Record.readDeclarationNameInfo(NameInfo);
68 ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
69 : Record(Record), DeclsCursor(Cursor) {}
71 /// \brief The number of record fields required for the Stmt class
73 static const unsigned NumStmtFields = 0;
75 /// \brief The number of record fields required for the Expr class
77 static const unsigned NumExprFields = NumStmtFields + 7;
79 /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
80 void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
81 TemplateArgumentLoc *ArgsLocArray,
82 unsigned NumTemplateArgs);
83 /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
84 void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
85 unsigned NumTemplateArgs);
87 void VisitStmt(Stmt *S);
88 #define STMT(Type, Base) \
89 void Visit##Type(Type *);
90 #include "clang/AST/StmtNodes.inc"
94 void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
95 TemplateArgumentLoc *ArgsLocArray,
96 unsigned NumTemplateArgs) {
97 SourceLocation TemplateKWLoc = ReadSourceLocation();
98 TemplateArgumentListInfo ArgInfo;
99 ArgInfo.setLAngleLoc(ReadSourceLocation());
100 ArgInfo.setRAngleLoc(ReadSourceLocation());
101 for (unsigned i = 0; i != NumTemplateArgs; ++i)
102 ArgInfo.addArgument(Record.readTemplateArgumentLoc());
103 Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
106 void ASTStmtReader::VisitStmt(Stmt *S) {
107 assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
110 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
112 S->setSemiLoc(ReadSourceLocation());
113 S->HasLeadingEmptyMacro = Record.readInt();
116 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
118 SmallVector<Stmt *, 16> Stmts;
119 unsigned NumStmts = Record.readInt();
121 Stmts.push_back(Record.readSubStmt());
122 S->setStmts(Record.getContext(), Stmts);
123 S->LBraceLoc = ReadSourceLocation();
124 S->RBraceLoc = ReadSourceLocation();
127 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
129 Record.recordSwitchCaseID(S, Record.readInt());
130 S->setKeywordLoc(ReadSourceLocation());
131 S->setColonLoc(ReadSourceLocation());
134 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
136 S->setLHS(Record.readSubExpr());
137 S->setRHS(Record.readSubExpr());
138 S->setSubStmt(Record.readSubStmt());
139 S->setEllipsisLoc(ReadSourceLocation());
142 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
144 S->setSubStmt(Record.readSubStmt());
147 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
149 LabelDecl *LD = ReadDeclAs<LabelDecl>();
152 S->setSubStmt(Record.readSubStmt());
153 S->setIdentLoc(ReadSourceLocation());
156 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
158 uint64_t NumAttrs = Record.readInt();
160 Record.readAttributes(Attrs);
162 assert(NumAttrs == S->NumAttrs);
163 assert(NumAttrs == Attrs.size());
164 std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
165 S->SubStmt = Record.readSubStmt();
166 S->AttrLoc = ReadSourceLocation();
169 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
171 S->setConstexpr(Record.readInt());
172 S->setInit(Record.readSubStmt());
173 S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
174 S->setCond(Record.readSubExpr());
175 S->setThen(Record.readSubStmt());
176 S->setElse(Record.readSubStmt());
177 S->setIfLoc(ReadSourceLocation());
178 S->setElseLoc(ReadSourceLocation());
181 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
183 S->setInit(Record.readSubStmt());
184 S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
185 S->setCond(Record.readSubExpr());
186 S->setBody(Record.readSubStmt());
187 S->setSwitchLoc(ReadSourceLocation());
188 if (Record.readInt())
189 S->setAllEnumCasesCovered();
191 SwitchCase *PrevSC = nullptr;
192 for (auto E = Record.size(); Record.getIdx() != E; ) {
193 SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt());
195 PrevSC->setNextSwitchCase(SC);
197 S->setSwitchCaseList(SC);
203 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
205 S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
207 S->setCond(Record.readSubExpr());
208 S->setBody(Record.readSubStmt());
209 S->setWhileLoc(ReadSourceLocation());
212 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
214 S->setCond(Record.readSubExpr());
215 S->setBody(Record.readSubStmt());
216 S->setDoLoc(ReadSourceLocation());
217 S->setWhileLoc(ReadSourceLocation());
218 S->setRParenLoc(ReadSourceLocation());
221 void ASTStmtReader::VisitForStmt(ForStmt *S) {
223 S->setInit(Record.readSubStmt());
224 S->setCond(Record.readSubExpr());
225 S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
226 S->setInc(Record.readSubExpr());
227 S->setBody(Record.readSubStmt());
228 S->setForLoc(ReadSourceLocation());
229 S->setLParenLoc(ReadSourceLocation());
230 S->setRParenLoc(ReadSourceLocation());
233 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
235 S->setLabel(ReadDeclAs<LabelDecl>());
236 S->setGotoLoc(ReadSourceLocation());
237 S->setLabelLoc(ReadSourceLocation());
240 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
242 S->setGotoLoc(ReadSourceLocation());
243 S->setStarLoc(ReadSourceLocation());
244 S->setTarget(Record.readSubExpr());
247 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
249 S->setContinueLoc(ReadSourceLocation());
252 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
254 S->setBreakLoc(ReadSourceLocation());
257 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
259 S->setRetValue(Record.readSubExpr());
260 S->setReturnLoc(ReadSourceLocation());
261 S->setNRVOCandidate(ReadDeclAs<VarDecl>());
264 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
266 S->setStartLoc(ReadSourceLocation());
267 S->setEndLoc(ReadSourceLocation());
269 if (Record.size() - Record.getIdx() == 1) {
270 // Single declaration
271 S->setDeclGroup(DeclGroupRef(ReadDecl()));
273 SmallVector<Decl *, 16> Decls;
274 int N = Record.size() - Record.getIdx();
276 for (int I = 0; I < N; ++I)
277 Decls.push_back(ReadDecl());
278 S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(),
284 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
286 S->NumOutputs = Record.readInt();
287 S->NumInputs = Record.readInt();
288 S->NumClobbers = Record.readInt();
289 S->setAsmLoc(ReadSourceLocation());
290 S->setVolatile(Record.readInt());
291 S->setSimple(Record.readInt());
294 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
296 S->setRParenLoc(ReadSourceLocation());
297 S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt()));
299 unsigned NumOutputs = S->getNumOutputs();
300 unsigned NumInputs = S->getNumInputs();
301 unsigned NumClobbers = S->getNumClobbers();
303 // Outputs and inputs
304 SmallVector<IdentifierInfo *, 16> Names;
305 SmallVector<StringLiteral*, 16> Constraints;
306 SmallVector<Stmt*, 16> Exprs;
307 for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
308 Names.push_back(Record.getIdentifierInfo());
309 Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
310 Exprs.push_back(Record.readSubStmt());
314 SmallVector<StringLiteral*, 16> Clobbers;
315 for (unsigned I = 0; I != NumClobbers; ++I)
316 Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
318 S->setOutputsAndInputsAndClobbers(Record.getContext(),
319 Names.data(), Constraints.data(),
320 Exprs.data(), NumOutputs, NumInputs,
321 Clobbers.data(), NumClobbers);
324 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
326 S->LBraceLoc = ReadSourceLocation();
327 S->EndLoc = ReadSourceLocation();
328 S->NumAsmToks = Record.readInt();
329 std::string AsmStr = ReadString();
332 SmallVector<Token, 16> AsmToks;
333 AsmToks.reserve(S->NumAsmToks);
334 for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
335 AsmToks.push_back(Record.readToken());
338 // The calls to reserve() for the FooData vectors are mandatory to
339 // prevent dead StringRefs in the Foo vectors.
341 // Read the clobbers.
342 SmallVector<std::string, 16> ClobbersData;
343 SmallVector<StringRef, 16> Clobbers;
344 ClobbersData.reserve(S->NumClobbers);
345 Clobbers.reserve(S->NumClobbers);
346 for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
347 ClobbersData.push_back(ReadString());
348 Clobbers.push_back(ClobbersData.back());
351 // Read the operands.
352 unsigned NumOperands = S->NumOutputs + S->NumInputs;
353 SmallVector<Expr*, 16> Exprs;
354 SmallVector<std::string, 16> ConstraintsData;
355 SmallVector<StringRef, 16> Constraints;
356 Exprs.reserve(NumOperands);
357 ConstraintsData.reserve(NumOperands);
358 Constraints.reserve(NumOperands);
359 for (unsigned i = 0; i != NumOperands; ++i) {
360 Exprs.push_back(cast<Expr>(Record.readSubStmt()));
361 ConstraintsData.push_back(ReadString());
362 Constraints.push_back(ConstraintsData.back());
365 S->initialize(Record.getContext(), AsmStr, AsmToks,
366 Constraints, Exprs, Clobbers);
369 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
370 // FIXME: Implement coroutine serialization.
371 llvm_unreachable("unimplemented");
374 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
375 // FIXME: Implement coroutine serialization.
376 llvm_unreachable("unimplemented");
379 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *S) {
380 // FIXME: Implement coroutine serialization.
381 llvm_unreachable("unimplemented");
384 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *S) {
385 // FIXME: Implement coroutine serialization.
386 llvm_unreachable("unimplemented");
389 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
392 S->setCapturedDecl(ReadDeclAs<CapturedDecl>());
393 S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
394 S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>());
397 for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
398 E = S->capture_init_end();
400 *I = Record.readSubExpr();
403 S->setCapturedStmt(Record.readSubStmt());
404 S->getCapturedDecl()->setBody(S->getCapturedStmt());
407 for (auto &I : S->captures()) {
408 I.VarAndKind.setPointer(ReadDeclAs<VarDecl>());
410 static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
411 I.Loc = ReadSourceLocation();
415 void ASTStmtReader::VisitExpr(Expr *E) {
417 E->setType(Record.readType());
418 E->setTypeDependent(Record.readInt());
419 E->setValueDependent(Record.readInt());
420 E->setInstantiationDependent(Record.readInt());
421 E->ExprBits.ContainsUnexpandedParameterPack = Record.readInt();
422 E->setValueKind(static_cast<ExprValueKind>(Record.readInt()));
423 E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt()));
424 assert(Record.getIdx() == NumExprFields &&
425 "Incorrect expression field count");
428 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
430 E->setLocation(ReadSourceLocation());
431 E->Type = (PredefinedExpr::IdentType)Record.readInt();
432 E->FnName = cast_or_null<StringLiteral>(Record.readSubExpr());
435 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
438 E->DeclRefExprBits.HasQualifier = Record.readInt();
439 E->DeclRefExprBits.HasFoundDecl = Record.readInt();
440 E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
441 E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
442 E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
443 unsigned NumTemplateArgs = 0;
444 if (E->hasTemplateKWAndArgsInfo())
445 NumTemplateArgs = Record.readInt();
447 if (E->hasQualifier())
448 new (E->getTrailingObjects<NestedNameSpecifierLoc>())
449 NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
451 if (E->hasFoundDecl())
452 *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>();
454 if (E->hasTemplateKWAndArgsInfo())
455 ReadTemplateKWAndArgsInfo(
456 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
457 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
459 E->setDecl(ReadDeclAs<ValueDecl>());
460 E->setLocation(ReadSourceLocation());
461 ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
464 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
466 E->setLocation(ReadSourceLocation());
467 E->setValue(Record.getContext(), Record.readAPInt());
470 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
472 E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record.readInt()));
473 E->setExact(Record.readInt());
474 E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
475 E->setLocation(ReadSourceLocation());
478 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
480 E->setSubExpr(Record.readSubExpr());
483 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
485 unsigned Len = Record.readInt();
486 assert(Record.peekInt() == E->getNumConcatenated() &&
487 "Wrong number of concatenated tokens!");
489 StringLiteral::StringKind kind =
490 static_cast<StringLiteral::StringKind>(Record.readInt());
491 bool isPascal = Record.readInt();
494 auto B = &Record.peekInt();
495 SmallString<16> Str(B, B + Len);
496 E->setString(Record.getContext(), Str, kind, isPascal);
497 Record.skipInts(Len);
499 // Read source locations
500 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
501 E->setStrTokenLoc(I, ReadSourceLocation());
504 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
506 E->setValue(Record.readInt());
507 E->setLocation(ReadSourceLocation());
508 E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
511 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
513 E->setLParen(ReadSourceLocation());
514 E->setRParen(ReadSourceLocation());
515 E->setSubExpr(Record.readSubExpr());
518 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
520 unsigned NumExprs = Record.readInt();
521 E->Exprs = new (Record.getContext()) Stmt*[NumExprs];
522 for (unsigned i = 0; i != NumExprs; ++i)
523 E->Exprs[i] = Record.readSubStmt();
524 E->NumExprs = NumExprs;
525 E->LParenLoc = ReadSourceLocation();
526 E->RParenLoc = ReadSourceLocation();
529 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
531 E->setSubExpr(Record.readSubExpr());
532 E->setOpcode((UnaryOperator::Opcode)Record.readInt());
533 E->setOperatorLoc(ReadSourceLocation());
536 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
538 assert(E->getNumComponents() == Record.peekInt());
540 assert(E->getNumExpressions() == Record.peekInt());
542 E->setOperatorLoc(ReadSourceLocation());
543 E->setRParenLoc(ReadSourceLocation());
544 E->setTypeSourceInfo(GetTypeSourceInfo());
545 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
546 OffsetOfNode::Kind Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
547 SourceLocation Start = ReadSourceLocation();
548 SourceLocation End = ReadSourceLocation();
550 case OffsetOfNode::Array:
551 E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
554 case OffsetOfNode::Field:
556 I, OffsetOfNode(Start, ReadDeclAs<FieldDecl>(), End));
559 case OffsetOfNode::Identifier:
562 OffsetOfNode(Start, Record.getIdentifierInfo(), End));
565 case OffsetOfNode::Base: {
566 CXXBaseSpecifier *Base = new (Record.getContext()) CXXBaseSpecifier();
567 *Base = Record.readCXXBaseSpecifier();
568 E->setComponent(I, OffsetOfNode(Base));
574 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
575 E->setIndexExpr(I, Record.readSubExpr());
578 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
580 E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
581 if (Record.peekInt() == 0) {
582 E->setArgument(Record.readSubExpr());
585 E->setArgument(GetTypeSourceInfo());
587 E->setOperatorLoc(ReadSourceLocation());
588 E->setRParenLoc(ReadSourceLocation());
591 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
593 E->setLHS(Record.readSubExpr());
594 E->setRHS(Record.readSubExpr());
595 E->setRBracketLoc(ReadSourceLocation());
598 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
600 E->setBase(Record.readSubExpr());
601 E->setLowerBound(Record.readSubExpr());
602 E->setLength(Record.readSubExpr());
603 E->setColonLoc(ReadSourceLocation());
604 E->setRBracketLoc(ReadSourceLocation());
607 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
609 E->setNumArgs(Record.getContext(), Record.readInt());
610 E->setRParenLoc(ReadSourceLocation());
611 E->setCallee(Record.readSubExpr());
612 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
613 E->setArg(I, Record.readSubExpr());
616 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
620 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
621 // Don't call VisitExpr, this is fully initialized at creation.
622 assert(E->getStmtClass() == Stmt::MemberExprClass &&
623 "It's a subclass, we must advance Idx!");
626 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
628 E->setBase(Record.readSubExpr());
629 E->setIsaMemberLoc(ReadSourceLocation());
630 E->setOpLoc(ReadSourceLocation());
631 E->setArrow(Record.readInt());
635 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
637 E->Operand = Record.readSubExpr();
638 E->setShouldCopy(Record.readInt());
641 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
642 VisitExplicitCastExpr(E);
643 E->LParenLoc = ReadSourceLocation();
644 E->BridgeKeywordLoc = ReadSourceLocation();
645 E->Kind = Record.readInt();
648 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
650 unsigned NumBaseSpecs = Record.readInt();
651 assert(NumBaseSpecs == E->path_size());
652 E->setSubExpr(Record.readSubExpr());
653 E->setCastKind((CastKind)Record.readInt());
654 CastExpr::path_iterator BaseI = E->path_begin();
655 while (NumBaseSpecs--) {
656 CXXBaseSpecifier *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
657 *BaseSpec = Record.readCXXBaseSpecifier();
662 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
664 E->setLHS(Record.readSubExpr());
665 E->setRHS(Record.readSubExpr());
666 E->setOpcode((BinaryOperator::Opcode)Record.readInt());
667 E->setOperatorLoc(ReadSourceLocation());
668 E->setFPContractable((bool)Record.readInt());
671 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
672 VisitBinaryOperator(E);
673 E->setComputationLHSType(Record.readType());
674 E->setComputationResultType(Record.readType());
677 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
679 E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
680 E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
681 E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
682 E->QuestionLoc = ReadSourceLocation();
683 E->ColonLoc = ReadSourceLocation();
687 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
689 E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
690 E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
691 E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
692 E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
693 E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
694 E->QuestionLoc = ReadSourceLocation();
695 E->ColonLoc = ReadSourceLocation();
698 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
702 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
704 E->setTypeInfoAsWritten(GetTypeSourceInfo());
707 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
708 VisitExplicitCastExpr(E);
709 E->setLParenLoc(ReadSourceLocation());
710 E->setRParenLoc(ReadSourceLocation());
713 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
715 E->setLParenLoc(ReadSourceLocation());
716 E->setTypeSourceInfo(GetTypeSourceInfo());
717 E->setInitializer(Record.readSubExpr());
718 E->setFileScope(Record.readInt());
721 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
723 E->setBase(Record.readSubExpr());
724 E->setAccessor(Record.getIdentifierInfo());
725 E->setAccessorLoc(ReadSourceLocation());
728 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
730 if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
731 E->setSyntacticForm(SyntForm);
732 E->setLBraceLoc(ReadSourceLocation());
733 E->setRBraceLoc(ReadSourceLocation());
734 bool isArrayFiller = Record.readInt();
735 Expr *filler = nullptr;
737 filler = Record.readSubExpr();
738 E->ArrayFillerOrUnionFieldInit = filler;
740 E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>();
741 E->sawArrayRangeDesignator(Record.readInt());
742 unsigned NumInits = Record.readInt();
743 E->reserveInits(Record.getContext(), NumInits);
745 for (unsigned I = 0; I != NumInits; ++I) {
746 Expr *init = Record.readSubExpr();
747 E->updateInit(Record.getContext(), I, init ? init : filler);
750 for (unsigned I = 0; I != NumInits; ++I)
751 E->updateInit(Record.getContext(), I, Record.readSubExpr());
755 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
756 typedef DesignatedInitExpr::Designator Designator;
759 unsigned NumSubExprs = Record.readInt();
760 assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
761 for (unsigned I = 0; I != NumSubExprs; ++I)
762 E->setSubExpr(I, Record.readSubExpr());
763 E->setEqualOrColonLoc(ReadSourceLocation());
764 E->setGNUSyntax(Record.readInt());
766 SmallVector<Designator, 4> Designators;
767 while (Record.getIdx() < Record.size()) {
768 switch ((DesignatorTypes)Record.readInt()) {
769 case DESIG_FIELD_DECL: {
770 FieldDecl *Field = ReadDeclAs<FieldDecl>();
771 SourceLocation DotLoc = ReadSourceLocation();
772 SourceLocation FieldLoc = ReadSourceLocation();
773 Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
775 Designators.back().setField(Field);
779 case DESIG_FIELD_NAME: {
780 const IdentifierInfo *Name = Record.getIdentifierInfo();
781 SourceLocation DotLoc = ReadSourceLocation();
782 SourceLocation FieldLoc = ReadSourceLocation();
783 Designators.push_back(Designator(Name, DotLoc, FieldLoc));
788 unsigned Index = Record.readInt();
789 SourceLocation LBracketLoc = ReadSourceLocation();
790 SourceLocation RBracketLoc = ReadSourceLocation();
791 Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
795 case DESIG_ARRAY_RANGE: {
796 unsigned Index = Record.readInt();
797 SourceLocation LBracketLoc = ReadSourceLocation();
798 SourceLocation EllipsisLoc = ReadSourceLocation();
799 SourceLocation RBracketLoc = ReadSourceLocation();
800 Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
806 E->setDesignators(Record.getContext(),
807 Designators.data(), Designators.size());
810 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
812 E->setBase(Record.readSubExpr());
813 E->setUpdater(Record.readSubExpr());
816 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
820 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
822 E->SubExprs[0] = Record.readSubExpr();
823 E->SubExprs[1] = Record.readSubExpr();
826 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
830 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
834 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
836 E->setSubExpr(Record.readSubExpr());
837 E->setWrittenTypeInfo(GetTypeSourceInfo());
838 E->setBuiltinLoc(ReadSourceLocation());
839 E->setRParenLoc(ReadSourceLocation());
840 E->setIsMicrosoftABI(Record.readInt());
843 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
845 E->setAmpAmpLoc(ReadSourceLocation());
846 E->setLabelLoc(ReadSourceLocation());
847 E->setLabel(ReadDeclAs<LabelDecl>());
850 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
852 E->setLParenLoc(ReadSourceLocation());
853 E->setRParenLoc(ReadSourceLocation());
854 E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
857 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
859 E->setCond(Record.readSubExpr());
860 E->setLHS(Record.readSubExpr());
861 E->setRHS(Record.readSubExpr());
862 E->setBuiltinLoc(ReadSourceLocation());
863 E->setRParenLoc(ReadSourceLocation());
864 E->setIsConditionTrue(Record.readInt());
867 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
869 E->setTokenLocation(ReadSourceLocation());
872 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
874 SmallVector<Expr *, 16> Exprs;
875 unsigned NumExprs = Record.readInt();
877 Exprs.push_back(Record.readSubExpr());
878 E->setExprs(Record.getContext(), Exprs);
879 E->setBuiltinLoc(ReadSourceLocation());
880 E->setRParenLoc(ReadSourceLocation());
883 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
885 E->BuiltinLoc = ReadSourceLocation();
886 E->RParenLoc = ReadSourceLocation();
887 E->TInfo = GetTypeSourceInfo();
888 E->SrcExpr = Record.readSubExpr();
891 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
893 E->setBlockDecl(ReadDeclAs<BlockDecl>());
896 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
898 E->NumAssocs = Record.readInt();
899 E->AssocTypes = new (Record.getContext()) TypeSourceInfo*[E->NumAssocs];
901 new(Record.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
903 E->SubExprs[GenericSelectionExpr::CONTROLLING] = Record.readSubExpr();
904 for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
905 E->AssocTypes[I] = GetTypeSourceInfo();
906 E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Record.readSubExpr();
908 E->ResultIndex = Record.readInt();
910 E->GenericLoc = ReadSourceLocation();
911 E->DefaultLoc = ReadSourceLocation();
912 E->RParenLoc = ReadSourceLocation();
915 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
917 unsigned numSemanticExprs = Record.readInt();
918 assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
919 E->PseudoObjectExprBits.ResultIndex = Record.readInt();
921 // Read the syntactic expression.
922 E->getSubExprsBuffer()[0] = Record.readSubExpr();
924 // Read all the semantic expressions.
925 for (unsigned i = 0; i != numSemanticExprs; ++i) {
926 Expr *subExpr = Record.readSubExpr();
927 E->getSubExprsBuffer()[i+1] = subExpr;
931 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
933 E->Op = AtomicExpr::AtomicOp(Record.readInt());
934 E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
935 for (unsigned I = 0; I != E->NumSubExprs; ++I)
936 E->SubExprs[I] = Record.readSubExpr();
937 E->BuiltinLoc = ReadSourceLocation();
938 E->RParenLoc = ReadSourceLocation();
941 //===----------------------------------------------------------------------===//
942 // Objective-C Expressions and Statements
944 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
946 E->setString(cast<StringLiteral>(Record.readSubStmt()));
947 E->setAtLoc(ReadSourceLocation());
950 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
952 // could be one of several IntegerLiteral, FloatLiteral, etc.
953 E->SubExpr = Record.readSubStmt();
954 E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>();
955 E->Range = ReadSourceRange();
958 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
960 unsigned NumElements = Record.readInt();
961 assert(NumElements == E->getNumElements() && "Wrong number of elements");
962 Expr **Elements = E->getElements();
963 for (unsigned I = 0, N = NumElements; I != N; ++I)
964 Elements[I] = Record.readSubExpr();
965 E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
966 E->Range = ReadSourceRange();
969 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
971 unsigned NumElements = Record.readInt();
972 assert(NumElements == E->getNumElements() && "Wrong number of elements");
973 bool HasPackExpansions = Record.readInt();
974 assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
975 ObjCDictionaryLiteral::KeyValuePair *KeyValues =
976 E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
977 ObjCDictionaryLiteral::ExpansionData *Expansions =
978 E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
979 for (unsigned I = 0; I != NumElements; ++I) {
980 KeyValues[I].Key = Record.readSubExpr();
981 KeyValues[I].Value = Record.readSubExpr();
982 if (HasPackExpansions) {
983 Expansions[I].EllipsisLoc = ReadSourceLocation();
984 Expansions[I].NumExpansionsPlusOne = Record.readInt();
987 E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
988 E->Range = ReadSourceRange();
991 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
993 E->setEncodedTypeSourceInfo(GetTypeSourceInfo());
994 E->setAtLoc(ReadSourceLocation());
995 E->setRParenLoc(ReadSourceLocation());
998 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1000 E->setSelector(Record.readSelector());
1001 E->setAtLoc(ReadSourceLocation());
1002 E->setRParenLoc(ReadSourceLocation());
1005 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1007 E->setProtocol(ReadDeclAs<ObjCProtocolDecl>());
1008 E->setAtLoc(ReadSourceLocation());
1009 E->ProtoLoc = ReadSourceLocation();
1010 E->setRParenLoc(ReadSourceLocation());
1013 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1015 E->setDecl(ReadDeclAs<ObjCIvarDecl>());
1016 E->setLocation(ReadSourceLocation());
1017 E->setOpLoc(ReadSourceLocation());
1018 E->setBase(Record.readSubExpr());
1019 E->setIsArrow(Record.readInt());
1020 E->setIsFreeIvar(Record.readInt());
1023 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1025 unsigned MethodRefFlags = Record.readInt();
1026 bool Implicit = Record.readInt() != 0;
1028 ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>();
1029 ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>();
1030 E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1032 E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
1034 E->setLocation(ReadSourceLocation());
1035 E->setReceiverLocation(ReadSourceLocation());
1036 switch (Record.readInt()) {
1038 E->setBase(Record.readSubExpr());
1041 E->setSuperReceiver(Record.readType());
1044 E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>());
1049 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1051 E->setRBracket(ReadSourceLocation());
1052 E->setBaseExpr(Record.readSubExpr());
1053 E->setKeyExpr(Record.readSubExpr());
1054 E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
1055 E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
1058 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1060 assert(Record.peekInt() == E->getNumArgs());
1062 unsigned NumStoredSelLocs = Record.readInt();
1063 E->SelLocsKind = Record.readInt();
1064 E->setDelegateInitCall(Record.readInt());
1065 E->IsImplicit = Record.readInt();
1066 ObjCMessageExpr::ReceiverKind Kind
1067 = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
1069 case ObjCMessageExpr::Instance:
1070 E->setInstanceReceiver(Record.readSubExpr());
1073 case ObjCMessageExpr::Class:
1074 E->setClassReceiver(GetTypeSourceInfo());
1077 case ObjCMessageExpr::SuperClass:
1078 case ObjCMessageExpr::SuperInstance: {
1079 QualType T = Record.readType();
1080 SourceLocation SuperLoc = ReadSourceLocation();
1081 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1086 assert(Kind == E->getReceiverKind());
1088 if (Record.readInt())
1089 E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>());
1091 E->setSelector(Record.readSelector());
1093 E->LBracLoc = ReadSourceLocation();
1094 E->RBracLoc = ReadSourceLocation();
1096 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1097 E->setArg(I, Record.readSubExpr());
1099 SourceLocation *Locs = E->getStoredSelLocs();
1100 for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1101 Locs[I] = ReadSourceLocation();
1104 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1106 S->setElement(Record.readSubStmt());
1107 S->setCollection(Record.readSubExpr());
1108 S->setBody(Record.readSubStmt());
1109 S->setForLoc(ReadSourceLocation());
1110 S->setRParenLoc(ReadSourceLocation());
1113 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1115 S->setCatchBody(Record.readSubStmt());
1116 S->setCatchParamDecl(ReadDeclAs<VarDecl>());
1117 S->setAtCatchLoc(ReadSourceLocation());
1118 S->setRParenLoc(ReadSourceLocation());
1121 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1123 S->setFinallyBody(Record.readSubStmt());
1124 S->setAtFinallyLoc(ReadSourceLocation());
1127 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1129 S->setSubStmt(Record.readSubStmt());
1130 S->setAtLoc(ReadSourceLocation());
1133 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1135 assert(Record.peekInt() == S->getNumCatchStmts());
1137 bool HasFinally = Record.readInt();
1138 S->setTryBody(Record.readSubStmt());
1139 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1140 S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt()));
1143 S->setFinallyStmt(Record.readSubStmt());
1144 S->setAtTryLoc(ReadSourceLocation());
1147 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1149 S->setSynchExpr(Record.readSubStmt());
1150 S->setSynchBody(Record.readSubStmt());
1151 S->setAtSynchronizedLoc(ReadSourceLocation());
1154 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1156 S->setThrowExpr(Record.readSubStmt());
1157 S->setThrowLoc(ReadSourceLocation());
1160 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1162 E->setValue(Record.readInt());
1163 E->setLocation(ReadSourceLocation());
1166 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1168 SourceRange R = Record.readSourceRange();
1169 E->AtLoc = R.getBegin();
1170 E->RParen = R.getEnd();
1171 E->VersionToCheck = Record.readVersionTuple();
1174 //===----------------------------------------------------------------------===//
1175 // C++ Expressions and Statements
1176 //===----------------------------------------------------------------------===//
1178 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1180 S->CatchLoc = ReadSourceLocation();
1181 S->ExceptionDecl = ReadDeclAs<VarDecl>();
1182 S->HandlerBlock = Record.readSubStmt();
1185 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1187 assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
1189 S->TryLoc = ReadSourceLocation();
1190 S->getStmts()[0] = Record.readSubStmt();
1191 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1192 S->getStmts()[i + 1] = Record.readSubStmt();
1195 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1197 S->ForLoc = ReadSourceLocation();
1198 S->CoawaitLoc = ReadSourceLocation();
1199 S->ColonLoc = ReadSourceLocation();
1200 S->RParenLoc = ReadSourceLocation();
1201 S->setRangeStmt(Record.readSubStmt());
1202 S->setBeginStmt(Record.readSubStmt());
1203 S->setEndStmt(Record.readSubStmt());
1204 S->setCond(Record.readSubExpr());
1205 S->setInc(Record.readSubExpr());
1206 S->setLoopVarStmt(Record.readSubStmt());
1207 S->setBody(Record.readSubStmt());
1210 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1212 S->KeywordLoc = ReadSourceLocation();
1213 S->IsIfExists = Record.readInt();
1214 S->QualifierLoc = Record.readNestedNameSpecifierLoc();
1215 ReadDeclarationNameInfo(S->NameInfo);
1216 S->SubStmt = Record.readSubStmt();
1219 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1221 E->Operator = (OverloadedOperatorKind)Record.readInt();
1222 E->Range = Record.readSourceRange();
1223 E->setFPContractable((bool)Record.readInt());
1226 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1228 E->NumArgs = Record.readInt();
1230 E->Args = new (Record.getContext()) Stmt*[E->NumArgs];
1231 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1232 E->setArg(I, Record.readSubExpr());
1233 E->setConstructor(ReadDeclAs<CXXConstructorDecl>());
1234 E->setLocation(ReadSourceLocation());
1235 E->setElidable(Record.readInt());
1236 E->setHadMultipleCandidates(Record.readInt());
1237 E->setListInitialization(Record.readInt());
1238 E->setStdInitListInitialization(Record.readInt());
1239 E->setRequiresZeroInitialization(Record.readInt());
1240 E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record.readInt());
1241 E->ParenOrBraceRange = ReadSourceRange();
1244 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1246 E->Constructor = ReadDeclAs<CXXConstructorDecl>();
1247 E->Loc = ReadSourceLocation();
1248 E->ConstructsVirtualBase = Record.readInt();
1249 E->InheritedFromVirtualBase = Record.readInt();
1252 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1253 VisitCXXConstructExpr(E);
1254 E->Type = GetTypeSourceInfo();
1257 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1259 unsigned NumCaptures = Record.readInt();
1260 assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
1261 E->IntroducerRange = ReadSourceRange();
1262 E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record.readInt());
1263 E->CaptureDefaultLoc = ReadSourceLocation();
1264 E->ExplicitParams = Record.readInt();
1265 E->ExplicitResultType = Record.readInt();
1266 E->ClosingBrace = ReadSourceLocation();
1268 // Read capture initializers.
1269 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1270 CEnd = E->capture_init_end();
1272 *C = Record.readSubExpr();
1276 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1278 E->SubExpr = Record.readSubExpr();
1281 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1282 VisitExplicitCastExpr(E);
1283 SourceRange R = ReadSourceRange();
1284 E->Loc = R.getBegin();
1285 E->RParenLoc = R.getEnd();
1286 R = ReadSourceRange();
1287 E->AngleBrackets = R;
1290 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1291 return VisitCXXNamedCastExpr(E);
1294 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1295 return VisitCXXNamedCastExpr(E);
1298 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1299 return VisitCXXNamedCastExpr(E);
1302 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1303 return VisitCXXNamedCastExpr(E);
1306 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1307 VisitExplicitCastExpr(E);
1308 E->setLParenLoc(ReadSourceLocation());
1309 E->setRParenLoc(ReadSourceLocation());
1312 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1314 E->UDSuffixLoc = ReadSourceLocation();
1317 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1319 E->setValue(Record.readInt());
1320 E->setLocation(ReadSourceLocation());
1323 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1325 E->setLocation(ReadSourceLocation());
1328 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1330 E->setSourceRange(ReadSourceRange());
1331 if (E->isTypeOperand()) { // typeid(int)
1332 E->setTypeOperandSourceInfo(
1333 GetTypeSourceInfo());
1338 E->setExprOperand(Record.readSubExpr());
1341 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1343 E->setLocation(ReadSourceLocation());
1344 E->setImplicit(Record.readInt());
1347 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1349 E->ThrowLoc = ReadSourceLocation();
1350 E->Op = Record.readSubExpr();
1351 E->IsThrownVariableInScope = Record.readInt();
1354 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1356 E->Param = ReadDeclAs<ParmVarDecl>();
1357 E->Loc = ReadSourceLocation();
1360 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1362 E->Field = ReadDeclAs<FieldDecl>();
1363 E->Loc = ReadSourceLocation();
1366 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1368 E->setTemporary(Record.readCXXTemporary());
1369 E->setSubExpr(Record.readSubExpr());
1372 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1374 E->TypeInfo = GetTypeSourceInfo();
1375 E->RParenLoc = ReadSourceLocation();
1378 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1380 E->GlobalNew = Record.readInt();
1381 bool isArray = Record.readInt();
1382 E->PassAlignment = Record.readInt();
1383 E->UsualArrayDeleteWantsSize = Record.readInt();
1384 unsigned NumPlacementArgs = Record.readInt();
1385 E->StoredInitializationStyle = Record.readInt();
1386 E->setOperatorNew(ReadDeclAs<FunctionDecl>());
1387 E->setOperatorDelete(ReadDeclAs<FunctionDecl>());
1388 E->AllocatedTypeInfo = GetTypeSourceInfo();
1389 E->TypeIdParens = ReadSourceRange();
1390 E->Range = ReadSourceRange();
1391 E->DirectInitRange = ReadSourceRange();
1393 E->AllocateArgsArray(Record.getContext(), isArray, NumPlacementArgs,
1394 E->StoredInitializationStyle != 0);
1396 // Install all the subexpressions.
1397 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1399 *I = Record.readSubStmt();
1402 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1404 E->GlobalDelete = Record.readInt();
1405 E->ArrayForm = Record.readInt();
1406 E->ArrayFormAsWritten = Record.readInt();
1407 E->UsualArrayDeleteWantsSize = Record.readInt();
1408 E->OperatorDelete = ReadDeclAs<FunctionDecl>();
1409 E->Argument = Record.readSubExpr();
1410 E->Loc = ReadSourceLocation();
1413 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1416 E->Base = Record.readSubExpr();
1417 E->IsArrow = Record.readInt();
1418 E->OperatorLoc = ReadSourceLocation();
1419 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1420 E->ScopeType = GetTypeSourceInfo();
1421 E->ColonColonLoc = ReadSourceLocation();
1422 E->TildeLoc = ReadSourceLocation();
1424 IdentifierInfo *II = Record.getIdentifierInfo();
1426 E->setDestroyedType(II, ReadSourceLocation());
1428 E->setDestroyedType(GetTypeSourceInfo());
1431 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1434 unsigned NumObjects = Record.readInt();
1435 assert(NumObjects == E->getNumObjects());
1436 for (unsigned i = 0; i != NumObjects; ++i)
1437 E->getTrailingObjects<BlockDecl *>()[i] =
1438 ReadDeclAs<BlockDecl>();
1440 E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
1441 E->SubExpr = Record.readSubExpr();
1445 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1448 if (Record.readInt()) // HasTemplateKWAndArgsInfo
1449 ReadTemplateKWAndArgsInfo(
1450 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1451 E->getTrailingObjects<TemplateArgumentLoc>(),
1452 /*NumTemplateArgs=*/Record.readInt());
1454 E->Base = Record.readSubExpr();
1455 E->BaseType = Record.readType();
1456 E->IsArrow = Record.readInt();
1457 E->OperatorLoc = ReadSourceLocation();
1458 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1459 E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>();
1460 ReadDeclarationNameInfo(E->MemberNameInfo);
1464 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1467 if (Record.readInt()) // HasTemplateKWAndArgsInfo
1468 ReadTemplateKWAndArgsInfo(
1469 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1470 E->getTrailingObjects<TemplateArgumentLoc>(),
1471 /*NumTemplateArgs=*/Record.readInt());
1473 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1474 ReadDeclarationNameInfo(E->NameInfo);
1478 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1480 assert(Record.peekInt() == E->arg_size() &&
1481 "Read wrong record during creation ?");
1483 for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1484 E->setArg(I, Record.readSubExpr());
1485 E->Type = GetTypeSourceInfo();
1486 E->setLParenLoc(ReadSourceLocation());
1487 E->setRParenLoc(ReadSourceLocation());
1490 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1493 if (Record.readInt()) // HasTemplateKWAndArgsInfo
1494 ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
1495 E->getTrailingTemplateArgumentLoc(),
1496 /*NumTemplateArgs=*/Record.readInt());
1498 unsigned NumDecls = Record.readInt();
1499 UnresolvedSet<8> Decls;
1500 for (unsigned i = 0; i != NumDecls; ++i) {
1501 NamedDecl *D = ReadDeclAs<NamedDecl>();
1502 AccessSpecifier AS = (AccessSpecifier)Record.readInt();
1503 Decls.addDecl(D, AS);
1505 E->initializeResults(Record.getContext(), Decls.begin(), Decls.end());
1507 ReadDeclarationNameInfo(E->NameInfo);
1508 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1511 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1512 VisitOverloadExpr(E);
1513 E->IsArrow = Record.readInt();
1514 E->HasUnresolvedUsing = Record.readInt();
1515 E->Base = Record.readSubExpr();
1516 E->BaseType = Record.readType();
1517 E->OperatorLoc = ReadSourceLocation();
1520 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1521 VisitOverloadExpr(E);
1522 E->RequiresADL = Record.readInt();
1523 E->Overloaded = Record.readInt();
1524 E->NamingClass = ReadDeclAs<CXXRecordDecl>();
1527 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
1529 E->TypeTraitExprBits.NumArgs = Record.readInt();
1530 E->TypeTraitExprBits.Kind = Record.readInt();
1531 E->TypeTraitExprBits.Value = Record.readInt();
1532 SourceRange Range = ReadSourceRange();
1533 E->Loc = Range.getBegin();
1534 E->RParenLoc = Range.getEnd();
1536 TypeSourceInfo **Args = E->getTrailingObjects<TypeSourceInfo *>();
1537 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1538 Args[I] = GetTypeSourceInfo();
1541 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1543 E->ATT = (ArrayTypeTrait)Record.readInt();
1544 E->Value = (unsigned int)Record.readInt();
1545 SourceRange Range = ReadSourceRange();
1546 E->Loc = Range.getBegin();
1547 E->RParen = Range.getEnd();
1548 E->QueriedType = GetTypeSourceInfo();
1549 E->Dimension = Record.readSubExpr();
1552 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1554 E->ET = (ExpressionTrait)Record.readInt();
1555 E->Value = (bool)Record.readInt();
1556 SourceRange Range = ReadSourceRange();
1557 E->QueriedExpression = Record.readSubExpr();
1558 E->Loc = Range.getBegin();
1559 E->RParen = Range.getEnd();
1562 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1564 E->Value = (bool)Record.readInt();
1565 E->Range = ReadSourceRange();
1566 E->Operand = Record.readSubExpr();
1569 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1571 E->EllipsisLoc = ReadSourceLocation();
1572 E->NumExpansions = Record.readInt();
1573 E->Pattern = Record.readSubExpr();
1576 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1578 unsigned NumPartialArgs = Record.readInt();
1579 E->OperatorLoc = ReadSourceLocation();
1580 E->PackLoc = ReadSourceLocation();
1581 E->RParenLoc = ReadSourceLocation();
1582 E->Pack = Record.readDeclAs<NamedDecl>();
1583 if (E->isPartiallySubstituted()) {
1584 assert(E->Length == NumPartialArgs);
1585 for (auto *I = E->getTrailingObjects<TemplateArgument>(),
1586 *E = I + NumPartialArgs;
1588 new (I) TemplateArgument(Record.readTemplateArgument());
1589 } else if (!E->isValueDependent()) {
1590 E->Length = Record.readInt();
1594 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1595 SubstNonTypeTemplateParmExpr *E) {
1597 E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
1598 E->NameLoc = ReadSourceLocation();
1599 E->Replacement = Record.readSubExpr();
1602 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1603 SubstNonTypeTemplateParmPackExpr *E) {
1605 E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
1606 TemplateArgument ArgPack = Record.readTemplateArgument();
1607 if (ArgPack.getKind() != TemplateArgument::Pack)
1610 E->Arguments = ArgPack.pack_begin();
1611 E->NumArguments = ArgPack.pack_size();
1612 E->NameLoc = ReadSourceLocation();
1615 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1617 E->NumParameters = Record.readInt();
1618 E->ParamPack = ReadDeclAs<ParmVarDecl>();
1619 E->NameLoc = ReadSourceLocation();
1620 ParmVarDecl **Parms = E->getTrailingObjects<ParmVarDecl *>();
1621 for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
1622 Parms[i] = ReadDeclAs<ParmVarDecl>();
1625 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1627 E->State = Record.readSubExpr();
1628 auto VD = ReadDeclAs<ValueDecl>();
1629 unsigned ManglingNumber = Record.readInt();
1630 E->setExtendingDecl(VD, ManglingNumber);
1633 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
1635 E->LParenLoc = ReadSourceLocation();
1636 E->EllipsisLoc = ReadSourceLocation();
1637 E->RParenLoc = ReadSourceLocation();
1638 E->SubExprs[0] = Record.readSubExpr();
1639 E->SubExprs[1] = Record.readSubExpr();
1640 E->Opcode = (BinaryOperatorKind)Record.readInt();
1643 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1645 E->SourceExpr = Record.readSubExpr();
1646 E->Loc = ReadSourceLocation();
1649 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
1650 llvm_unreachable("Cannot read TypoExpr nodes");
1653 //===----------------------------------------------------------------------===//
1654 // Microsoft Expressions and Statements
1655 //===----------------------------------------------------------------------===//
1656 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1658 E->IsArrow = (Record.readInt() != 0);
1659 E->BaseExpr = Record.readSubExpr();
1660 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1661 E->MemberLoc = ReadSourceLocation();
1662 E->TheDecl = ReadDeclAs<MSPropertyDecl>();
1665 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
1667 E->setBase(Record.readSubExpr());
1668 E->setIdx(Record.readSubExpr());
1669 E->setRBracketLoc(ReadSourceLocation());
1672 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1674 E->setSourceRange(ReadSourceRange());
1675 std::string UuidStr = ReadString();
1676 E->setUuidStr(StringRef(UuidStr).copy(Record.getContext()));
1677 if (E->isTypeOperand()) { // __uuidof(ComType)
1678 E->setTypeOperandSourceInfo(
1679 GetTypeSourceInfo());
1684 E->setExprOperand(Record.readSubExpr());
1687 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1689 S->setLeaveLoc(ReadSourceLocation());
1692 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1694 S->Loc = ReadSourceLocation();
1695 S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
1696 S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
1699 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1701 S->Loc = ReadSourceLocation();
1702 S->Block = Record.readSubStmt();
1705 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1707 S->IsCXXTry = Record.readInt();
1708 S->TryLoc = ReadSourceLocation();
1709 S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
1710 S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
1713 //===----------------------------------------------------------------------===//
1714 // CUDA Expressions and Statements
1715 //===----------------------------------------------------------------------===//
1717 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1719 E->setConfig(cast<CallExpr>(Record.readSubExpr()));
1722 //===----------------------------------------------------------------------===//
1723 // OpenCL Expressions and Statements.
1724 //===----------------------------------------------------------------------===//
1725 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1727 E->BuiltinLoc = ReadSourceLocation();
1728 E->RParenLoc = ReadSourceLocation();
1729 E->SrcExpr = Record.readSubExpr();
1732 //===----------------------------------------------------------------------===//
1734 //===----------------------------------------------------------------------===//
1737 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
1738 ASTStmtReader *Reader;
1739 ASTContext &Context;
1741 OMPClauseReader(ASTStmtReader *R, ASTRecordReader &Record)
1742 : Reader(R), Context(Record.getContext()) {}
1743 #define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *C);
1744 #include "clang/Basic/OpenMPKinds.def"
1745 OMPClause *readClause();
1746 void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
1747 void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
1751 OMPClause *OMPClauseReader::readClause() {
1753 switch (Reader->Record.readInt()) {
1755 C = new (Context) OMPIfClause();
1758 C = new (Context) OMPFinalClause();
1760 case OMPC_num_threads:
1761 C = new (Context) OMPNumThreadsClause();
1764 C = new (Context) OMPSafelenClause();
1767 C = new (Context) OMPSimdlenClause();
1770 C = new (Context) OMPCollapseClause();
1773 C = new (Context) OMPDefaultClause();
1775 case OMPC_proc_bind:
1776 C = new (Context) OMPProcBindClause();
1779 C = new (Context) OMPScheduleClause();
1782 C = new (Context) OMPOrderedClause();
1785 C = new (Context) OMPNowaitClause();
1788 C = new (Context) OMPUntiedClause();
1790 case OMPC_mergeable:
1791 C = new (Context) OMPMergeableClause();
1794 C = new (Context) OMPReadClause();
1797 C = new (Context) OMPWriteClause();
1800 C = new (Context) OMPUpdateClause();
1803 C = new (Context) OMPCaptureClause();
1806 C = new (Context) OMPSeqCstClause();
1809 C = new (Context) OMPThreadsClause();
1812 C = new (Context) OMPSIMDClause();
1815 C = new (Context) OMPNogroupClause();
1818 C = OMPPrivateClause::CreateEmpty(Context, Reader->Record.readInt());
1820 case OMPC_firstprivate:
1821 C = OMPFirstprivateClause::CreateEmpty(Context, Reader->Record.readInt());
1823 case OMPC_lastprivate:
1824 C = OMPLastprivateClause::CreateEmpty(Context, Reader->Record.readInt());
1827 C = OMPSharedClause::CreateEmpty(Context, Reader->Record.readInt());
1829 case OMPC_reduction:
1830 C = OMPReductionClause::CreateEmpty(Context, Reader->Record.readInt());
1833 C = OMPLinearClause::CreateEmpty(Context, Reader->Record.readInt());
1836 C = OMPAlignedClause::CreateEmpty(Context, Reader->Record.readInt());
1839 C = OMPCopyinClause::CreateEmpty(Context, Reader->Record.readInt());
1841 case OMPC_copyprivate:
1842 C = OMPCopyprivateClause::CreateEmpty(Context, Reader->Record.readInt());
1845 C = OMPFlushClause::CreateEmpty(Context, Reader->Record.readInt());
1848 C = OMPDependClause::CreateEmpty(Context, Reader->Record.readInt());
1851 C = new (Context) OMPDeviceClause();
1854 unsigned NumVars = Reader->Record.readInt();
1855 unsigned NumDeclarations = Reader->Record.readInt();
1856 unsigned NumLists = Reader->Record.readInt();
1857 unsigned NumComponents = Reader->Record.readInt();
1858 C = OMPMapClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
1862 case OMPC_num_teams:
1863 C = new (Context) OMPNumTeamsClause();
1865 case OMPC_thread_limit:
1866 C = new (Context) OMPThreadLimitClause();
1869 C = new (Context) OMPPriorityClause();
1871 case OMPC_grainsize:
1872 C = new (Context) OMPGrainsizeClause();
1874 case OMPC_num_tasks:
1875 C = new (Context) OMPNumTasksClause();
1878 C = new (Context) OMPHintClause();
1880 case OMPC_dist_schedule:
1881 C = new (Context) OMPDistScheduleClause();
1883 case OMPC_defaultmap:
1884 C = new (Context) OMPDefaultmapClause();
1887 unsigned NumVars = Reader->Record.readInt();
1888 unsigned NumDeclarations = Reader->Record.readInt();
1889 unsigned NumLists = Reader->Record.readInt();
1890 unsigned NumComponents = Reader->Record.readInt();
1891 C = OMPToClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
1896 unsigned NumVars = Reader->Record.readInt();
1897 unsigned NumDeclarations = Reader->Record.readInt();
1898 unsigned NumLists = Reader->Record.readInt();
1899 unsigned NumComponents = Reader->Record.readInt();
1900 C = OMPFromClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
1904 case OMPC_use_device_ptr: {
1905 unsigned NumVars = Reader->Record.readInt();
1906 unsigned NumDeclarations = Reader->Record.readInt();
1907 unsigned NumLists = Reader->Record.readInt();
1908 unsigned NumComponents = Reader->Record.readInt();
1909 C = OMPUseDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations,
1910 NumLists, NumComponents);
1913 case OMPC_is_device_ptr: {
1914 unsigned NumVars = Reader->Record.readInt();
1915 unsigned NumDeclarations = Reader->Record.readInt();
1916 unsigned NumLists = Reader->Record.readInt();
1917 unsigned NumComponents = Reader->Record.readInt();
1918 C = OMPIsDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations,
1919 NumLists, NumComponents);
1924 C->setLocStart(Reader->ReadSourceLocation());
1925 C->setLocEnd(Reader->ReadSourceLocation());
1930 void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
1931 C->setPreInitStmt(Reader->Record.readSubStmt());
1934 void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
1935 VisitOMPClauseWithPreInit(C);
1936 C->setPostUpdateExpr(Reader->Record.readSubExpr());
1939 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
1940 C->setNameModifier(static_cast<OpenMPDirectiveKind>(Reader->Record.readInt()));
1941 C->setNameModifierLoc(Reader->ReadSourceLocation());
1942 C->setColonLoc(Reader->ReadSourceLocation());
1943 C->setCondition(Reader->Record.readSubExpr());
1944 C->setLParenLoc(Reader->ReadSourceLocation());
1947 void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
1948 C->setCondition(Reader->Record.readSubExpr());
1949 C->setLParenLoc(Reader->ReadSourceLocation());
1952 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1953 C->setNumThreads(Reader->Record.readSubExpr());
1954 C->setLParenLoc(Reader->ReadSourceLocation());
1957 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
1958 C->setSafelen(Reader->Record.readSubExpr());
1959 C->setLParenLoc(Reader->ReadSourceLocation());
1962 void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
1963 C->setSimdlen(Reader->Record.readSubExpr());
1964 C->setLParenLoc(Reader->ReadSourceLocation());
1967 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
1968 C->setNumForLoops(Reader->Record.readSubExpr());
1969 C->setLParenLoc(Reader->ReadSourceLocation());
1972 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
1974 static_cast<OpenMPDefaultClauseKind>(Reader->Record.readInt()));
1975 C->setLParenLoc(Reader->ReadSourceLocation());
1976 C->setDefaultKindKwLoc(Reader->ReadSourceLocation());
1979 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
1981 static_cast<OpenMPProcBindClauseKind>(Reader->Record.readInt()));
1982 C->setLParenLoc(Reader->ReadSourceLocation());
1983 C->setProcBindKindKwLoc(Reader->ReadSourceLocation());
1986 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
1987 VisitOMPClauseWithPreInit(C);
1989 static_cast<OpenMPScheduleClauseKind>(Reader->Record.readInt()));
1990 C->setFirstScheduleModifier(
1991 static_cast<OpenMPScheduleClauseModifier>(Reader->Record.readInt()));
1992 C->setSecondScheduleModifier(
1993 static_cast<OpenMPScheduleClauseModifier>(Reader->Record.readInt()));
1994 C->setChunkSize(Reader->Record.readSubExpr());
1995 C->setLParenLoc(Reader->ReadSourceLocation());
1996 C->setFirstScheduleModifierLoc(Reader->ReadSourceLocation());
1997 C->setSecondScheduleModifierLoc(Reader->ReadSourceLocation());
1998 C->setScheduleKindLoc(Reader->ReadSourceLocation());
1999 C->setCommaLoc(Reader->ReadSourceLocation());
2002 void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
2003 C->setNumForLoops(Reader->Record.readSubExpr());
2004 C->setLParenLoc(Reader->ReadSourceLocation());
2007 void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
2009 void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
2011 void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
2013 void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
2015 void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
2017 void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *) {}
2019 void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
2021 void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
2023 void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
2025 void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
2027 void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
2029 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
2030 C->setLParenLoc(Reader->ReadSourceLocation());
2031 unsigned NumVars = C->varlist_size();
2032 SmallVector<Expr *, 16> Vars;
2033 Vars.reserve(NumVars);
2034 for (unsigned i = 0; i != NumVars; ++i)
2035 Vars.push_back(Reader->Record.readSubExpr());
2036 C->setVarRefs(Vars);
2038 for (unsigned i = 0; i != NumVars; ++i)
2039 Vars.push_back(Reader->Record.readSubExpr());
2040 C->setPrivateCopies(Vars);
2043 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
2044 VisitOMPClauseWithPreInit(C);
2045 C->setLParenLoc(Reader->ReadSourceLocation());
2046 unsigned NumVars = C->varlist_size();
2047 SmallVector<Expr *, 16> Vars;
2048 Vars.reserve(NumVars);
2049 for (unsigned i = 0; i != NumVars; ++i)
2050 Vars.push_back(Reader->Record.readSubExpr());
2051 C->setVarRefs(Vars);
2053 for (unsigned i = 0; i != NumVars; ++i)
2054 Vars.push_back(Reader->Record.readSubExpr());
2055 C->setPrivateCopies(Vars);
2057 for (unsigned i = 0; i != NumVars; ++i)
2058 Vars.push_back(Reader->Record.readSubExpr());
2062 void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
2063 VisitOMPClauseWithPostUpdate(C);
2064 C->setLParenLoc(Reader->ReadSourceLocation());
2065 unsigned NumVars = C->varlist_size();
2066 SmallVector<Expr *, 16> Vars;
2067 Vars.reserve(NumVars);
2068 for (unsigned i = 0; i != NumVars; ++i)
2069 Vars.push_back(Reader->Record.readSubExpr());
2070 C->setVarRefs(Vars);
2072 for (unsigned i = 0; i != NumVars; ++i)
2073 Vars.push_back(Reader->Record.readSubExpr());
2074 C->setPrivateCopies(Vars);
2076 for (unsigned i = 0; i != NumVars; ++i)
2077 Vars.push_back(Reader->Record.readSubExpr());
2078 C->setSourceExprs(Vars);
2080 for (unsigned i = 0; i != NumVars; ++i)
2081 Vars.push_back(Reader->Record.readSubExpr());
2082 C->setDestinationExprs(Vars);
2084 for (unsigned i = 0; i != NumVars; ++i)
2085 Vars.push_back(Reader->Record.readSubExpr());
2086 C->setAssignmentOps(Vars);
2089 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
2090 C->setLParenLoc(Reader->ReadSourceLocation());
2091 unsigned NumVars = C->varlist_size();
2092 SmallVector<Expr *, 16> Vars;
2093 Vars.reserve(NumVars);
2094 for (unsigned i = 0; i != NumVars; ++i)
2095 Vars.push_back(Reader->Record.readSubExpr());
2096 C->setVarRefs(Vars);
2099 void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
2100 VisitOMPClauseWithPostUpdate(C);
2101 C->setLParenLoc(Reader->ReadSourceLocation());
2102 C->setColonLoc(Reader->ReadSourceLocation());
2103 NestedNameSpecifierLoc NNSL = Reader->Record.readNestedNameSpecifierLoc();
2104 DeclarationNameInfo DNI;
2105 Reader->ReadDeclarationNameInfo(DNI);
2106 C->setQualifierLoc(NNSL);
2107 C->setNameInfo(DNI);
2109 unsigned NumVars = C->varlist_size();
2110 SmallVector<Expr *, 16> Vars;
2111 Vars.reserve(NumVars);
2112 for (unsigned i = 0; i != NumVars; ++i)
2113 Vars.push_back(Reader->Record.readSubExpr());
2114 C->setVarRefs(Vars);
2116 for (unsigned i = 0; i != NumVars; ++i)
2117 Vars.push_back(Reader->Record.readSubExpr());
2118 C->setPrivates(Vars);
2120 for (unsigned i = 0; i != NumVars; ++i)
2121 Vars.push_back(Reader->Record.readSubExpr());
2122 C->setLHSExprs(Vars);
2124 for (unsigned i = 0; i != NumVars; ++i)
2125 Vars.push_back(Reader->Record.readSubExpr());
2126 C->setRHSExprs(Vars);
2128 for (unsigned i = 0; i != NumVars; ++i)
2129 Vars.push_back(Reader->Record.readSubExpr());
2130 C->setReductionOps(Vars);
2133 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
2134 VisitOMPClauseWithPostUpdate(C);
2135 C->setLParenLoc(Reader->ReadSourceLocation());
2136 C->setColonLoc(Reader->ReadSourceLocation());
2137 C->setModifier(static_cast<OpenMPLinearClauseKind>(Reader->Record.readInt()));
2138 C->setModifierLoc(Reader->ReadSourceLocation());
2139 unsigned NumVars = C->varlist_size();
2140 SmallVector<Expr *, 16> Vars;
2141 Vars.reserve(NumVars);
2142 for (unsigned i = 0; i != NumVars; ++i)
2143 Vars.push_back(Reader->Record.readSubExpr());
2144 C->setVarRefs(Vars);
2146 for (unsigned i = 0; i != NumVars; ++i)
2147 Vars.push_back(Reader->Record.readSubExpr());
2148 C->setPrivates(Vars);
2150 for (unsigned i = 0; i != NumVars; ++i)
2151 Vars.push_back(Reader->Record.readSubExpr());
2154 for (unsigned i = 0; i != NumVars; ++i)
2155 Vars.push_back(Reader->Record.readSubExpr());
2156 C->setUpdates(Vars);
2158 for (unsigned i = 0; i != NumVars; ++i)
2159 Vars.push_back(Reader->Record.readSubExpr());
2161 C->setStep(Reader->Record.readSubExpr());
2162 C->setCalcStep(Reader->Record.readSubExpr());
2165 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
2166 C->setLParenLoc(Reader->ReadSourceLocation());
2167 C->setColonLoc(Reader->ReadSourceLocation());
2168 unsigned NumVars = C->varlist_size();
2169 SmallVector<Expr *, 16> Vars;
2170 Vars.reserve(NumVars);
2171 for (unsigned i = 0; i != NumVars; ++i)
2172 Vars.push_back(Reader->Record.readSubExpr());
2173 C->setVarRefs(Vars);
2174 C->setAlignment(Reader->Record.readSubExpr());
2177 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
2178 C->setLParenLoc(Reader->ReadSourceLocation());
2179 unsigned NumVars = C->varlist_size();
2180 SmallVector<Expr *, 16> Exprs;
2181 Exprs.reserve(NumVars);
2182 for (unsigned i = 0; i != NumVars; ++i)
2183 Exprs.push_back(Reader->Record.readSubExpr());
2184 C->setVarRefs(Exprs);
2186 for (unsigned i = 0; i != NumVars; ++i)
2187 Exprs.push_back(Reader->Record.readSubExpr());
2188 C->setSourceExprs(Exprs);
2190 for (unsigned i = 0; i != NumVars; ++i)
2191 Exprs.push_back(Reader->Record.readSubExpr());
2192 C->setDestinationExprs(Exprs);
2194 for (unsigned i = 0; i != NumVars; ++i)
2195 Exprs.push_back(Reader->Record.readSubExpr());
2196 C->setAssignmentOps(Exprs);
2199 void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
2200 C->setLParenLoc(Reader->ReadSourceLocation());
2201 unsigned NumVars = C->varlist_size();
2202 SmallVector<Expr *, 16> Exprs;
2203 Exprs.reserve(NumVars);
2204 for (unsigned i = 0; i != NumVars; ++i)
2205 Exprs.push_back(Reader->Record.readSubExpr());
2206 C->setVarRefs(Exprs);
2208 for (unsigned i = 0; i != NumVars; ++i)
2209 Exprs.push_back(Reader->Record.readSubExpr());
2210 C->setSourceExprs(Exprs);
2212 for (unsigned i = 0; i != NumVars; ++i)
2213 Exprs.push_back(Reader->Record.readSubExpr());
2214 C->setDestinationExprs(Exprs);
2216 for (unsigned i = 0; i != NumVars; ++i)
2217 Exprs.push_back(Reader->Record.readSubExpr());
2218 C->setAssignmentOps(Exprs);
2221 void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
2222 C->setLParenLoc(Reader->ReadSourceLocation());
2223 unsigned NumVars = C->varlist_size();
2224 SmallVector<Expr *, 16> Vars;
2225 Vars.reserve(NumVars);
2226 for (unsigned i = 0; i != NumVars; ++i)
2227 Vars.push_back(Reader->Record.readSubExpr());
2228 C->setVarRefs(Vars);
2231 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
2232 C->setLParenLoc(Reader->ReadSourceLocation());
2233 C->setDependencyKind(
2234 static_cast<OpenMPDependClauseKind>(Reader->Record.readInt()));
2235 C->setDependencyLoc(Reader->ReadSourceLocation());
2236 C->setColonLoc(Reader->ReadSourceLocation());
2237 unsigned NumVars = C->varlist_size();
2238 SmallVector<Expr *, 16> Vars;
2239 Vars.reserve(NumVars);
2240 for (unsigned i = 0; i != NumVars; ++i)
2241 Vars.push_back(Reader->Record.readSubExpr());
2242 C->setVarRefs(Vars);
2243 C->setCounterValue(Reader->Record.readSubExpr());
2246 void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
2247 C->setDevice(Reader->Record.readSubExpr());
2248 C->setLParenLoc(Reader->ReadSourceLocation());
2251 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
2252 C->setLParenLoc(Reader->ReadSourceLocation());
2253 C->setMapTypeModifier(
2254 static_cast<OpenMPMapClauseKind>(Reader->Record.readInt()));
2256 static_cast<OpenMPMapClauseKind>(Reader->Record.readInt()));
2257 C->setMapLoc(Reader->ReadSourceLocation());
2258 C->setColonLoc(Reader->ReadSourceLocation());
2259 auto NumVars = C->varlist_size();
2260 auto UniqueDecls = C->getUniqueDeclarationsNum();
2261 auto TotalLists = C->getTotalComponentListNum();
2262 auto TotalComponents = C->getTotalComponentsNum();
2264 SmallVector<Expr *, 16> Vars;
2265 Vars.reserve(NumVars);
2266 for (unsigned i = 0; i != NumVars; ++i)
2267 Vars.push_back(Reader->Record.readSubExpr());
2268 C->setVarRefs(Vars);
2270 SmallVector<ValueDecl *, 16> Decls;
2271 Decls.reserve(UniqueDecls);
2272 for (unsigned i = 0; i < UniqueDecls; ++i)
2273 Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2274 C->setUniqueDecls(Decls);
2276 SmallVector<unsigned, 16> ListsPerDecl;
2277 ListsPerDecl.reserve(UniqueDecls);
2278 for (unsigned i = 0; i < UniqueDecls; ++i)
2279 ListsPerDecl.push_back(Reader->Record.readInt());
2280 C->setDeclNumLists(ListsPerDecl);
2282 SmallVector<unsigned, 32> ListSizes;
2283 ListSizes.reserve(TotalLists);
2284 for (unsigned i = 0; i < TotalLists; ++i)
2285 ListSizes.push_back(Reader->Record.readInt());
2286 C->setComponentListSizes(ListSizes);
2288 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2289 Components.reserve(TotalComponents);
2290 for (unsigned i = 0; i < TotalComponents; ++i) {
2291 Expr *AssociatedExpr = Reader->Record.readSubExpr();
2292 ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2293 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2294 AssociatedExpr, AssociatedDecl));
2296 C->setComponents(Components, ListSizes);
2299 void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
2300 C->setNumTeams(Reader->Record.readSubExpr());
2301 C->setLParenLoc(Reader->ReadSourceLocation());
2304 void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
2305 C->setThreadLimit(Reader->Record.readSubExpr());
2306 C->setLParenLoc(Reader->ReadSourceLocation());
2309 void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
2310 C->setPriority(Reader->Record.readSubExpr());
2311 C->setLParenLoc(Reader->ReadSourceLocation());
2314 void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
2315 C->setGrainsize(Reader->Record.readSubExpr());
2316 C->setLParenLoc(Reader->ReadSourceLocation());
2319 void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
2320 C->setNumTasks(Reader->Record.readSubExpr());
2321 C->setLParenLoc(Reader->ReadSourceLocation());
2324 void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
2325 C->setHint(Reader->Record.readSubExpr());
2326 C->setLParenLoc(Reader->ReadSourceLocation());
2329 void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
2330 VisitOMPClauseWithPreInit(C);
2331 C->setDistScheduleKind(
2332 static_cast<OpenMPDistScheduleClauseKind>(Reader->Record.readInt()));
2333 C->setChunkSize(Reader->Record.readSubExpr());
2334 C->setLParenLoc(Reader->ReadSourceLocation());
2335 C->setDistScheduleKindLoc(Reader->ReadSourceLocation());
2336 C->setCommaLoc(Reader->ReadSourceLocation());
2339 void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
2340 C->setDefaultmapKind(
2341 static_cast<OpenMPDefaultmapClauseKind>(Reader->Record.readInt()));
2342 C->setDefaultmapModifier(
2343 static_cast<OpenMPDefaultmapClauseModifier>(Reader->Record.readInt()));
2344 C->setLParenLoc(Reader->ReadSourceLocation());
2345 C->setDefaultmapModifierLoc(Reader->ReadSourceLocation());
2346 C->setDefaultmapKindLoc(Reader->ReadSourceLocation());
2349 void OMPClauseReader::VisitOMPToClause(OMPToClause *C) {
2350 C->setLParenLoc(Reader->ReadSourceLocation());
2351 auto NumVars = C->varlist_size();
2352 auto UniqueDecls = C->getUniqueDeclarationsNum();
2353 auto TotalLists = C->getTotalComponentListNum();
2354 auto TotalComponents = C->getTotalComponentsNum();
2356 SmallVector<Expr *, 16> Vars;
2357 Vars.reserve(NumVars);
2358 for (unsigned i = 0; i != NumVars; ++i)
2359 Vars.push_back(Reader->Record.readSubExpr());
2360 C->setVarRefs(Vars);
2362 SmallVector<ValueDecl *, 16> Decls;
2363 Decls.reserve(UniqueDecls);
2364 for (unsigned i = 0; i < UniqueDecls; ++i)
2365 Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2366 C->setUniqueDecls(Decls);
2368 SmallVector<unsigned, 16> ListsPerDecl;
2369 ListsPerDecl.reserve(UniqueDecls);
2370 for (unsigned i = 0; i < UniqueDecls; ++i)
2371 ListsPerDecl.push_back(Reader->Record.readInt());
2372 C->setDeclNumLists(ListsPerDecl);
2374 SmallVector<unsigned, 32> ListSizes;
2375 ListSizes.reserve(TotalLists);
2376 for (unsigned i = 0; i < TotalLists; ++i)
2377 ListSizes.push_back(Reader->Record.readInt());
2378 C->setComponentListSizes(ListSizes);
2380 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2381 Components.reserve(TotalComponents);
2382 for (unsigned i = 0; i < TotalComponents; ++i) {
2383 Expr *AssociatedExpr = Reader->Record.readSubExpr();
2384 ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2385 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2386 AssociatedExpr, AssociatedDecl));
2388 C->setComponents(Components, ListSizes);
2391 void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
2392 C->setLParenLoc(Reader->ReadSourceLocation());
2393 auto NumVars = C->varlist_size();
2394 auto UniqueDecls = C->getUniqueDeclarationsNum();
2395 auto TotalLists = C->getTotalComponentListNum();
2396 auto TotalComponents = C->getTotalComponentsNum();
2398 SmallVector<Expr *, 16> Vars;
2399 Vars.reserve(NumVars);
2400 for (unsigned i = 0; i != NumVars; ++i)
2401 Vars.push_back(Reader->Record.readSubExpr());
2402 C->setVarRefs(Vars);
2404 SmallVector<ValueDecl *, 16> Decls;
2405 Decls.reserve(UniqueDecls);
2406 for (unsigned i = 0; i < UniqueDecls; ++i)
2407 Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2408 C->setUniqueDecls(Decls);
2410 SmallVector<unsigned, 16> ListsPerDecl;
2411 ListsPerDecl.reserve(UniqueDecls);
2412 for (unsigned i = 0; i < UniqueDecls; ++i)
2413 ListsPerDecl.push_back(Reader->Record.readInt());
2414 C->setDeclNumLists(ListsPerDecl);
2416 SmallVector<unsigned, 32> ListSizes;
2417 ListSizes.reserve(TotalLists);
2418 for (unsigned i = 0; i < TotalLists; ++i)
2419 ListSizes.push_back(Reader->Record.readInt());
2420 C->setComponentListSizes(ListSizes);
2422 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2423 Components.reserve(TotalComponents);
2424 for (unsigned i = 0; i < TotalComponents; ++i) {
2425 Expr *AssociatedExpr = Reader->Record.readSubExpr();
2426 ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2427 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2428 AssociatedExpr, AssociatedDecl));
2430 C->setComponents(Components, ListSizes);
2433 void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
2434 C->setLParenLoc(Reader->ReadSourceLocation());
2435 auto NumVars = C->varlist_size();
2436 auto UniqueDecls = C->getUniqueDeclarationsNum();
2437 auto TotalLists = C->getTotalComponentListNum();
2438 auto TotalComponents = C->getTotalComponentsNum();
2440 SmallVector<Expr *, 16> Vars;
2441 Vars.reserve(NumVars);
2442 for (unsigned i = 0; i != NumVars; ++i)
2443 Vars.push_back(Reader->Record.readSubExpr());
2444 C->setVarRefs(Vars);
2446 for (unsigned i = 0; i != NumVars; ++i)
2447 Vars.push_back(Reader->Record.readSubExpr());
2448 C->setPrivateCopies(Vars);
2450 for (unsigned i = 0; i != NumVars; ++i)
2451 Vars.push_back(Reader->Record.readSubExpr());
2454 SmallVector<ValueDecl *, 16> Decls;
2455 Decls.reserve(UniqueDecls);
2456 for (unsigned i = 0; i < UniqueDecls; ++i)
2457 Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2458 C->setUniqueDecls(Decls);
2460 SmallVector<unsigned, 16> ListsPerDecl;
2461 ListsPerDecl.reserve(UniqueDecls);
2462 for (unsigned i = 0; i < UniqueDecls; ++i)
2463 ListsPerDecl.push_back(Reader->Record.readInt());
2464 C->setDeclNumLists(ListsPerDecl);
2466 SmallVector<unsigned, 32> ListSizes;
2467 ListSizes.reserve(TotalLists);
2468 for (unsigned i = 0; i < TotalLists; ++i)
2469 ListSizes.push_back(Reader->Record.readInt());
2470 C->setComponentListSizes(ListSizes);
2472 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2473 Components.reserve(TotalComponents);
2474 for (unsigned i = 0; i < TotalComponents; ++i) {
2475 Expr *AssociatedExpr = Reader->Record.readSubExpr();
2476 ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2477 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2478 AssociatedExpr, AssociatedDecl));
2480 C->setComponents(Components, ListSizes);
2483 void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
2484 C->setLParenLoc(Reader->ReadSourceLocation());
2485 auto NumVars = C->varlist_size();
2486 auto UniqueDecls = C->getUniqueDeclarationsNum();
2487 auto TotalLists = C->getTotalComponentListNum();
2488 auto TotalComponents = C->getTotalComponentsNum();
2490 SmallVector<Expr *, 16> Vars;
2491 Vars.reserve(NumVars);
2492 for (unsigned i = 0; i != NumVars; ++i)
2493 Vars.push_back(Reader->Record.readSubExpr());
2494 C->setVarRefs(Vars);
2497 SmallVector<ValueDecl *, 16> Decls;
2498 Decls.reserve(UniqueDecls);
2499 for (unsigned i = 0; i < UniqueDecls; ++i)
2500 Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2501 C->setUniqueDecls(Decls);
2503 SmallVector<unsigned, 16> ListsPerDecl;
2504 ListsPerDecl.reserve(UniqueDecls);
2505 for (unsigned i = 0; i < UniqueDecls; ++i)
2506 ListsPerDecl.push_back(Reader->Record.readInt());
2507 C->setDeclNumLists(ListsPerDecl);
2509 SmallVector<unsigned, 32> ListSizes;
2510 ListSizes.reserve(TotalLists);
2511 for (unsigned i = 0; i < TotalLists; ++i)
2512 ListSizes.push_back(Reader->Record.readInt());
2513 C->setComponentListSizes(ListSizes);
2515 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2516 Components.reserve(TotalComponents);
2517 for (unsigned i = 0; i < TotalComponents; ++i) {
2518 Expr *AssociatedExpr = Reader->Record.readSubExpr();
2519 ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2520 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2521 AssociatedExpr, AssociatedDecl));
2523 C->setComponents(Components, ListSizes);
2526 //===----------------------------------------------------------------------===//
2527 // OpenMP Directives.
2528 //===----------------------------------------------------------------------===//
2529 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2530 E->setLocStart(ReadSourceLocation());
2531 E->setLocEnd(ReadSourceLocation());
2532 OMPClauseReader ClauseReader(this, Record);
2533 SmallVector<OMPClause *, 5> Clauses;
2534 for (unsigned i = 0; i < E->getNumClauses(); ++i)
2535 Clauses.push_back(ClauseReader.readClause());
2536 E->setClauses(Clauses);
2537 if (E->hasAssociatedStmt())
2538 E->setAssociatedStmt(Record.readSubStmt());
2541 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2543 // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
2545 VisitOMPExecutableDirective(D);
2546 D->setIterationVariable(Record.readSubExpr());
2547 D->setLastIteration(Record.readSubExpr());
2548 D->setCalcLastIteration(Record.readSubExpr());
2549 D->setPreCond(Record.readSubExpr());
2550 D->setCond(Record.readSubExpr());
2551 D->setInit(Record.readSubExpr());
2552 D->setInc(Record.readSubExpr());
2553 D->setPreInits(Record.readSubStmt());
2554 if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
2555 isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
2556 isOpenMPDistributeDirective(D->getDirectiveKind())) {
2557 D->setIsLastIterVariable(Record.readSubExpr());
2558 D->setLowerBoundVariable(Record.readSubExpr());
2559 D->setUpperBoundVariable(Record.readSubExpr());
2560 D->setStrideVariable(Record.readSubExpr());
2561 D->setEnsureUpperBound(Record.readSubExpr());
2562 D->setNextLowerBound(Record.readSubExpr());
2563 D->setNextUpperBound(Record.readSubExpr());
2564 D->setNumIterations(Record.readSubExpr());
2566 if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
2567 D->setPrevLowerBoundVariable(Record.readSubExpr());
2568 D->setPrevUpperBoundVariable(Record.readSubExpr());
2570 SmallVector<Expr *, 4> Sub;
2571 unsigned CollapsedNum = D->getCollapsedNumber();
2572 Sub.reserve(CollapsedNum);
2573 for (unsigned i = 0; i < CollapsedNum; ++i)
2574 Sub.push_back(Record.readSubExpr());
2575 D->setCounters(Sub);
2577 for (unsigned i = 0; i < CollapsedNum; ++i)
2578 Sub.push_back(Record.readSubExpr());
2579 D->setPrivateCounters(Sub);
2581 for (unsigned i = 0; i < CollapsedNum; ++i)
2582 Sub.push_back(Record.readSubExpr());
2585 for (unsigned i = 0; i < CollapsedNum; ++i)
2586 Sub.push_back(Record.readSubExpr());
2589 for (unsigned i = 0; i < CollapsedNum; ++i)
2590 Sub.push_back(Record.readSubExpr());
2594 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2596 // The NumClauses field was read in ReadStmtFromStream.
2598 VisitOMPExecutableDirective(D);
2599 D->setHasCancel(Record.readInt());
2602 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2603 VisitOMPLoopDirective(D);
2606 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2607 VisitOMPLoopDirective(D);
2608 D->setHasCancel(Record.readInt());
2611 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2612 VisitOMPLoopDirective(D);
2615 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2617 // The NumClauses field was read in ReadStmtFromStream.
2619 VisitOMPExecutableDirective(D);
2620 D->setHasCancel(Record.readInt());
2623 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2625 VisitOMPExecutableDirective(D);
2626 D->setHasCancel(Record.readInt());
2629 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2631 // The NumClauses field was read in ReadStmtFromStream.
2633 VisitOMPExecutableDirective(D);
2636 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2638 VisitOMPExecutableDirective(D);
2641 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2643 // The NumClauses field was read in ReadStmtFromStream.
2645 VisitOMPExecutableDirective(D);
2646 ReadDeclarationNameInfo(D->DirName);
2649 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2650 VisitOMPLoopDirective(D);
2651 D->setHasCancel(Record.readInt());
2654 void ASTStmtReader::VisitOMPParallelForSimdDirective(
2655 OMPParallelForSimdDirective *D) {
2656 VisitOMPLoopDirective(D);
2659 void ASTStmtReader::VisitOMPParallelSectionsDirective(
2660 OMPParallelSectionsDirective *D) {
2662 // The NumClauses field was read in ReadStmtFromStream.
2664 VisitOMPExecutableDirective(D);
2665 D->setHasCancel(Record.readInt());
2668 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2670 // The NumClauses field was read in ReadStmtFromStream.
2672 VisitOMPExecutableDirective(D);
2673 D->setHasCancel(Record.readInt());
2676 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2678 VisitOMPExecutableDirective(D);
2681 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2683 VisitOMPExecutableDirective(D);
2686 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2688 VisitOMPExecutableDirective(D);
2691 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2693 VisitOMPExecutableDirective(D);
2696 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2698 // The NumClauses field was read in ReadStmtFromStream.
2700 VisitOMPExecutableDirective(D);
2703 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2705 // The NumClauses field was read in ReadStmtFromStream.
2707 VisitOMPExecutableDirective(D);
2710 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2712 // The NumClauses field was read in ReadStmtFromStream.
2714 VisitOMPExecutableDirective(D);
2715 D->setX(Record.readSubExpr());
2716 D->setV(Record.readSubExpr());
2717 D->setExpr(Record.readSubExpr());
2718 D->setUpdateExpr(Record.readSubExpr());
2719 D->IsXLHSInRHSPart = Record.readInt() != 0;
2720 D->IsPostfixUpdate = Record.readInt() != 0;
2723 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2725 // The NumClauses field was read in ReadStmtFromStream.
2727 VisitOMPExecutableDirective(D);
2730 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2733 VisitOMPExecutableDirective(D);
2736 void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2737 OMPTargetEnterDataDirective *D) {
2740 VisitOMPExecutableDirective(D);
2743 void ASTStmtReader::VisitOMPTargetExitDataDirective(
2744 OMPTargetExitDataDirective *D) {
2747 VisitOMPExecutableDirective(D);
2750 void ASTStmtReader::VisitOMPTargetParallelDirective(
2751 OMPTargetParallelDirective *D) {
2754 VisitOMPExecutableDirective(D);
2757 void ASTStmtReader::VisitOMPTargetParallelForDirective(
2758 OMPTargetParallelForDirective *D) {
2759 VisitOMPLoopDirective(D);
2760 D->setHasCancel(Record.readInt());
2763 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2765 // The NumClauses field was read in ReadStmtFromStream.
2767 VisitOMPExecutableDirective(D);
2770 void ASTStmtReader::VisitOMPCancellationPointDirective(
2771 OMPCancellationPointDirective *D) {
2773 VisitOMPExecutableDirective(D);
2774 D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2777 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2779 // The NumClauses field was read in ReadStmtFromStream.
2781 VisitOMPExecutableDirective(D);
2782 D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2785 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2786 VisitOMPLoopDirective(D);
2789 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2790 VisitOMPLoopDirective(D);
2793 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2794 VisitOMPLoopDirective(D);
2797 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2800 VisitOMPExecutableDirective(D);
2802 void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2803 OMPDistributeParallelForDirective *D) {
2804 VisitOMPLoopDirective(D);
2807 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2808 OMPDistributeParallelForSimdDirective *D) {
2809 VisitOMPLoopDirective(D);
2812 void ASTStmtReader::VisitOMPDistributeSimdDirective(
2813 OMPDistributeSimdDirective *D) {
2814 VisitOMPLoopDirective(D);
2817 void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2818 OMPTargetParallelForSimdDirective *D) {
2819 VisitOMPLoopDirective(D);
2822 void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2823 VisitOMPLoopDirective(D);
2826 void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2827 OMPTeamsDistributeDirective *D) {
2828 VisitOMPLoopDirective(D);
2831 void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2832 OMPTeamsDistributeSimdDirective *D) {
2833 VisitOMPLoopDirective(D);
2836 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2837 OMPTeamsDistributeParallelForSimdDirective *D) {
2838 VisitOMPLoopDirective(D);
2841 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2842 OMPTeamsDistributeParallelForDirective *D) {
2843 VisitOMPLoopDirective(D);
2846 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2848 // The NumClauses field was read in ReadStmtFromStream.
2850 VisitOMPExecutableDirective(D);
2853 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2854 OMPTargetTeamsDistributeDirective *D) {
2855 VisitOMPLoopDirective(D);
2858 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2859 OMPTargetTeamsDistributeParallelForDirective *D) {
2860 VisitOMPLoopDirective(D);
2863 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2864 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2865 VisitOMPLoopDirective(D);
2868 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2869 OMPTargetTeamsDistributeSimdDirective *D) {
2870 VisitOMPLoopDirective(D);
2873 //===----------------------------------------------------------------------===//
2874 // ASTReader Implementation
2875 //===----------------------------------------------------------------------===//
2877 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
2878 switch (ReadingKind) {
2880 llvm_unreachable("should not call this when not reading anything");
2883 return ReadStmtFromStream(F);
2885 return ReadSubStmt();
2888 llvm_unreachable("ReadingKind not set ?");
2891 Expr *ASTReader::ReadExpr(ModuleFile &F) {
2892 return cast_or_null<Expr>(ReadStmt(F));
2895 Expr *ASTReader::ReadSubExpr() {
2896 return cast_or_null<Expr>(ReadSubStmt());
2899 // Within the bitstream, expressions are stored in Reverse Polish
2900 // Notation, with each of the subexpressions preceding the
2901 // expression they are stored in. Subexpressions are stored from last to first.
2902 // To evaluate expressions, we continue reading expressions and placing them on
2903 // the stack, with expressions having operands removing those operands from the
2904 // stack. Evaluation terminates when we see a STMT_STOP record, and
2905 // the single remaining expression on the stack is our result.
2906 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2908 ReadingKindTracker ReadingKind(Read_Stmt, *this);
2909 llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2911 // Map of offset to previously deserialized stmt. The offset points
2912 /// just after the stmt record.
2913 llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2916 unsigned PrevNumStmts = StmtStack.size();
2919 ASTRecordReader Record(*this, F);
2920 ASTStmtReader Reader(Record, Cursor);
2921 Stmt::EmptyShell Empty;
2924 llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();
2926 switch (Entry.Kind) {
2927 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2928 case llvm::BitstreamEntry::Error:
2929 Error("malformed block record in AST file");
2931 case llvm::BitstreamEntry::EndBlock:
2933 case llvm::BitstreamEntry::Record:
2934 // The interesting case.
2939 bool Finished = false;
2940 bool IsStmtReference = false;
2941 switch ((StmtCode)Record.readRecord(Cursor, Entry.ID)) {
2947 IsStmtReference = true;
2948 assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
2949 "No stmt was recorded for this offset reference!");
2950 S = StmtEntries[Record.readInt()];
2958 S = new (Context) NullStmt(Empty);
2962 S = new (Context) CompoundStmt(Empty);
2966 S = new (Context) CaseStmt(Empty);
2970 S = new (Context) DefaultStmt(Empty);
2974 S = new (Context) LabelStmt(Empty);
2977 case STMT_ATTRIBUTED:
2978 S = AttributedStmt::CreateEmpty(
2980 /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
2984 S = new (Context) IfStmt(Empty);
2988 S = new (Context) SwitchStmt(Empty);
2992 S = new (Context) WhileStmt(Empty);
2996 S = new (Context) DoStmt(Empty);
3000 S = new (Context) ForStmt(Empty);
3004 S = new (Context) GotoStmt(Empty);
3007 case STMT_INDIRECT_GOTO:
3008 S = new (Context) IndirectGotoStmt(Empty);
3012 S = new (Context) ContinueStmt(Empty);
3016 S = new (Context) BreakStmt(Empty);
3020 S = new (Context) ReturnStmt(Empty);
3024 S = new (Context) DeclStmt(Empty);
3028 S = new (Context) GCCAsmStmt(Empty);
3032 S = new (Context) MSAsmStmt(Empty);
3036 S = CapturedStmt::CreateDeserialized(Context,
3037 Record[ASTStmtReader::NumStmtFields]);
3040 case EXPR_PREDEFINED:
3041 S = new (Context) PredefinedExpr(Empty);
3045 S = DeclRefExpr::CreateEmpty(
3047 /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
3048 /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
3049 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
3050 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
3051 Record[ASTStmtReader::NumExprFields + 5] : 0);
3054 case EXPR_INTEGER_LITERAL:
3055 S = IntegerLiteral::Create(Context, Empty);
3058 case EXPR_FLOATING_LITERAL:
3059 S = FloatingLiteral::Create(Context, Empty);
3062 case EXPR_IMAGINARY_LITERAL:
3063 S = new (Context) ImaginaryLiteral(Empty);
3066 case EXPR_STRING_LITERAL:
3067 S = StringLiteral::CreateEmpty(Context,
3068 Record[ASTStmtReader::NumExprFields + 1]);
3071 case EXPR_CHARACTER_LITERAL:
3072 S = new (Context) CharacterLiteral(Empty);
3076 S = new (Context) ParenExpr(Empty);
3079 case EXPR_PAREN_LIST:
3080 S = new (Context) ParenListExpr(Empty);
3083 case EXPR_UNARY_OPERATOR:
3084 S = new (Context) UnaryOperator(Empty);
3088 S = OffsetOfExpr::CreateEmpty(Context,
3089 Record[ASTStmtReader::NumExprFields],
3090 Record[ASTStmtReader::NumExprFields + 1]);
3093 case EXPR_SIZEOF_ALIGN_OF:
3094 S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
3097 case EXPR_ARRAY_SUBSCRIPT:
3098 S = new (Context) ArraySubscriptExpr(Empty);
3101 case EXPR_OMP_ARRAY_SECTION:
3102 S = new (Context) OMPArraySectionExpr(Empty);
3106 S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
3110 // We load everything here and fully initialize it at creation.
3111 // That way we can use MemberExpr::Create and don't have to duplicate its
3112 // logic with a MemberExpr::CreateEmpty.
3114 assert(Record.getIdx() == 0);
3115 NestedNameSpecifierLoc QualifierLoc;
3116 if (Record.readInt()) { // HasQualifier.
3117 QualifierLoc = Record.readNestedNameSpecifierLoc();
3120 SourceLocation TemplateKWLoc;
3121 TemplateArgumentListInfo ArgInfo;
3122 bool HasTemplateKWAndArgsInfo = Record.readInt();
3123 if (HasTemplateKWAndArgsInfo) {
3124 TemplateKWLoc = Record.readSourceLocation();
3125 unsigned NumTemplateArgs = Record.readInt();
3126 ArgInfo.setLAngleLoc(Record.readSourceLocation());
3127 ArgInfo.setRAngleLoc(Record.readSourceLocation());
3128 for (unsigned i = 0; i != NumTemplateArgs; ++i)
3129 ArgInfo.addArgument(Record.readTemplateArgumentLoc());
3132 bool HadMultipleCandidates = Record.readInt();
3134 NamedDecl *FoundD = Record.readDeclAs<NamedDecl>();
3135 AccessSpecifier AS = (AccessSpecifier)Record.readInt();
3136 DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
3138 QualType T = Record.readType();
3139 ExprValueKind VK = static_cast<ExprValueKind>(Record.readInt());
3140 ExprObjectKind OK = static_cast<ExprObjectKind>(Record.readInt());
3141 Expr *Base = ReadSubExpr();
3142 ValueDecl *MemberD = Record.readDeclAs<ValueDecl>();
3143 SourceLocation MemberLoc = Record.readSourceLocation();
3144 DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
3145 bool IsArrow = Record.readInt();
3146 SourceLocation OperatorLoc = Record.readSourceLocation();
3148 S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,
3149 TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
3150 HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,
3152 Record.readDeclarationNameLoc(cast<MemberExpr>(S)->MemberDNLoc,
3153 MemberD->getDeclName());
3154 if (HadMultipleCandidates)
3155 cast<MemberExpr>(S)->setHadMultipleCandidates(true);
3159 case EXPR_BINARY_OPERATOR:
3160 S = new (Context) BinaryOperator(Empty);
3163 case EXPR_COMPOUND_ASSIGN_OPERATOR:
3164 S = new (Context) CompoundAssignOperator(Empty);
3167 case EXPR_CONDITIONAL_OPERATOR:
3168 S = new (Context) ConditionalOperator(Empty);
3171 case EXPR_BINARY_CONDITIONAL_OPERATOR:
3172 S = new (Context) BinaryConditionalOperator(Empty);
3175 case EXPR_IMPLICIT_CAST:
3176 S = ImplicitCastExpr::CreateEmpty(Context,
3177 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3180 case EXPR_CSTYLE_CAST:
3181 S = CStyleCastExpr::CreateEmpty(Context,
3182 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3185 case EXPR_COMPOUND_LITERAL:
3186 S = new (Context) CompoundLiteralExpr(Empty);
3189 case EXPR_EXT_VECTOR_ELEMENT:
3190 S = new (Context) ExtVectorElementExpr(Empty);
3193 case EXPR_INIT_LIST:
3194 S = new (Context) InitListExpr(Empty);
3197 case EXPR_DESIGNATED_INIT:
3198 S = DesignatedInitExpr::CreateEmpty(Context,
3199 Record[ASTStmtReader::NumExprFields] - 1);
3203 case EXPR_DESIGNATED_INIT_UPDATE:
3204 S = new (Context) DesignatedInitUpdateExpr(Empty);
3207 case EXPR_IMPLICIT_VALUE_INIT:
3208 S = new (Context) ImplicitValueInitExpr(Empty);
3212 S = new (Context) NoInitExpr(Empty);
3215 case EXPR_ARRAY_INIT_LOOP:
3216 S = new (Context) ArrayInitLoopExpr(Empty);
3219 case EXPR_ARRAY_INIT_INDEX:
3220 S = new (Context) ArrayInitIndexExpr(Empty);
3224 S = new (Context) VAArgExpr(Empty);
3227 case EXPR_ADDR_LABEL:
3228 S = new (Context) AddrLabelExpr(Empty);
3232 S = new (Context) StmtExpr(Empty);
3236 S = new (Context) ChooseExpr(Empty);
3240 S = new (Context) GNUNullExpr(Empty);
3243 case EXPR_SHUFFLE_VECTOR:
3244 S = new (Context) ShuffleVectorExpr(Empty);
3247 case EXPR_CONVERT_VECTOR:
3248 S = new (Context) ConvertVectorExpr(Empty);
3252 S = new (Context) BlockExpr(Empty);
3255 case EXPR_GENERIC_SELECTION:
3256 S = new (Context) GenericSelectionExpr(Empty);
3259 case EXPR_OBJC_STRING_LITERAL:
3260 S = new (Context) ObjCStringLiteral(Empty);
3262 case EXPR_OBJC_BOXED_EXPRESSION:
3263 S = new (Context) ObjCBoxedExpr(Empty);
3265 case EXPR_OBJC_ARRAY_LITERAL:
3266 S = ObjCArrayLiteral::CreateEmpty(Context,
3267 Record[ASTStmtReader::NumExprFields]);
3269 case EXPR_OBJC_DICTIONARY_LITERAL:
3270 S = ObjCDictionaryLiteral::CreateEmpty(Context,
3271 Record[ASTStmtReader::NumExprFields],
3272 Record[ASTStmtReader::NumExprFields + 1]);
3274 case EXPR_OBJC_ENCODE:
3275 S = new (Context) ObjCEncodeExpr(Empty);
3277 case EXPR_OBJC_SELECTOR_EXPR:
3278 S = new (Context) ObjCSelectorExpr(Empty);
3280 case EXPR_OBJC_PROTOCOL_EXPR:
3281 S = new (Context) ObjCProtocolExpr(Empty);
3283 case EXPR_OBJC_IVAR_REF_EXPR:
3284 S = new (Context) ObjCIvarRefExpr(Empty);
3286 case EXPR_OBJC_PROPERTY_REF_EXPR:
3287 S = new (Context) ObjCPropertyRefExpr(Empty);
3289 case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
3290 S = new (Context) ObjCSubscriptRefExpr(Empty);
3292 case EXPR_OBJC_KVC_REF_EXPR:
3293 llvm_unreachable("mismatching AST file");
3294 case EXPR_OBJC_MESSAGE_EXPR:
3295 S = ObjCMessageExpr::CreateEmpty(Context,
3296 Record[ASTStmtReader::NumExprFields],
3297 Record[ASTStmtReader::NumExprFields + 1]);
3300 S = new (Context) ObjCIsaExpr(Empty);
3302 case EXPR_OBJC_INDIRECT_COPY_RESTORE:
3303 S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3305 case EXPR_OBJC_BRIDGED_CAST:
3306 S = new (Context) ObjCBridgedCastExpr(Empty);
3308 case STMT_OBJC_FOR_COLLECTION:
3309 S = new (Context) ObjCForCollectionStmt(Empty);
3311 case STMT_OBJC_CATCH:
3312 S = new (Context) ObjCAtCatchStmt(Empty);
3314 case STMT_OBJC_FINALLY:
3315 S = new (Context) ObjCAtFinallyStmt(Empty);
3317 case STMT_OBJC_AT_TRY:
3318 S = ObjCAtTryStmt::CreateEmpty(Context,
3319 Record[ASTStmtReader::NumStmtFields],
3320 Record[ASTStmtReader::NumStmtFields + 1]);
3322 case STMT_OBJC_AT_SYNCHRONIZED:
3323 S = new (Context) ObjCAtSynchronizedStmt(Empty);
3325 case STMT_OBJC_AT_THROW:
3326 S = new (Context) ObjCAtThrowStmt(Empty);
3328 case STMT_OBJC_AUTORELEASE_POOL:
3329 S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3331 case EXPR_OBJC_BOOL_LITERAL:
3332 S = new (Context) ObjCBoolLiteralExpr(Empty);
3334 case EXPR_OBJC_AVAILABILITY_CHECK:
3335 S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3337 case STMT_SEH_LEAVE:
3338 S = new (Context) SEHLeaveStmt(Empty);
3340 case STMT_SEH_EXCEPT:
3341 S = new (Context) SEHExceptStmt(Empty);
3343 case STMT_SEH_FINALLY:
3344 S = new (Context) SEHFinallyStmt(Empty);
3347 S = new (Context) SEHTryStmt(Empty);
3349 case STMT_CXX_CATCH:
3350 S = new (Context) CXXCatchStmt(Empty);
3354 S = CXXTryStmt::Create(Context, Empty,
3355 /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3358 case STMT_CXX_FOR_RANGE:
3359 S = new (Context) CXXForRangeStmt(Empty);
3362 case STMT_MS_DEPENDENT_EXISTS:
3363 S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3364 NestedNameSpecifierLoc(),
3365 DeclarationNameInfo(),
3369 case STMT_OMP_PARALLEL_DIRECTIVE:
3371 OMPParallelDirective::CreateEmpty(Context,
3372 Record[ASTStmtReader::NumStmtFields],
3376 case STMT_OMP_SIMD_DIRECTIVE: {
3377 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3378 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3379 S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
3380 CollapsedNum, Empty);
3384 case STMT_OMP_FOR_DIRECTIVE: {
3385 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3386 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3387 S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3392 case STMT_OMP_FOR_SIMD_DIRECTIVE: {
3393 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3394 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3395 S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3400 case STMT_OMP_SECTIONS_DIRECTIVE:
3401 S = OMPSectionsDirective::CreateEmpty(
3402 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3405 case STMT_OMP_SECTION_DIRECTIVE:
3406 S = OMPSectionDirective::CreateEmpty(Context, Empty);
3409 case STMT_OMP_SINGLE_DIRECTIVE:
3410 S = OMPSingleDirective::CreateEmpty(
3411 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3414 case STMT_OMP_MASTER_DIRECTIVE:
3415 S = OMPMasterDirective::CreateEmpty(Context, Empty);
3418 case STMT_OMP_CRITICAL_DIRECTIVE:
3419 S = OMPCriticalDirective::CreateEmpty(
3420 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3423 case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
3424 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3425 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3426 S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
3427 CollapsedNum, Empty);
3431 case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
3432 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3433 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3434 S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3435 CollapsedNum, Empty);
3439 case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
3440 S = OMPParallelSectionsDirective::CreateEmpty(
3441 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3444 case STMT_OMP_TASK_DIRECTIVE:
3445 S = OMPTaskDirective::CreateEmpty(
3446 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3449 case STMT_OMP_TASKYIELD_DIRECTIVE:
3450 S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
3453 case STMT_OMP_BARRIER_DIRECTIVE:
3454 S = OMPBarrierDirective::CreateEmpty(Context, Empty);
3457 case STMT_OMP_TASKWAIT_DIRECTIVE:
3458 S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
3461 case STMT_OMP_TASKGROUP_DIRECTIVE:
3462 S = OMPTaskgroupDirective::CreateEmpty(Context, Empty);
3465 case STMT_OMP_FLUSH_DIRECTIVE:
3466 S = OMPFlushDirective::CreateEmpty(
3467 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3470 case STMT_OMP_ORDERED_DIRECTIVE:
3471 S = OMPOrderedDirective::CreateEmpty(
3472 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3475 case STMT_OMP_ATOMIC_DIRECTIVE:
3476 S = OMPAtomicDirective::CreateEmpty(
3477 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3480 case STMT_OMP_TARGET_DIRECTIVE:
3481 S = OMPTargetDirective::CreateEmpty(
3482 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3485 case STMT_OMP_TARGET_DATA_DIRECTIVE:
3486 S = OMPTargetDataDirective::CreateEmpty(
3487 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3490 case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE:
3491 S = OMPTargetEnterDataDirective::CreateEmpty(
3492 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3495 case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE:
3496 S = OMPTargetExitDataDirective::CreateEmpty(
3497 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3500 case STMT_OMP_TARGET_PARALLEL_DIRECTIVE:
3501 S = OMPTargetParallelDirective::CreateEmpty(
3502 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3505 case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: {
3506 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3507 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3508 S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
3509 CollapsedNum, Empty);
3513 case STMT_OMP_TARGET_UPDATE_DIRECTIVE:
3514 S = OMPTargetUpdateDirective::CreateEmpty(
3515 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3518 case STMT_OMP_TEAMS_DIRECTIVE:
3519 S = OMPTeamsDirective::CreateEmpty(
3520 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3523 case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
3524 S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3527 case STMT_OMP_CANCEL_DIRECTIVE:
3528 S = OMPCancelDirective::CreateEmpty(
3529 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3532 case STMT_OMP_TASKLOOP_DIRECTIVE: {
3533 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3534 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3535 S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3540 case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
3541 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3542 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3543 S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3544 CollapsedNum, Empty);
3548 case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
3549 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3550 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3551 S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3556 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3557 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3558 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3559 S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
3560 CollapsedNum, Empty);
3564 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3565 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3566 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3567 S = OMPDistributeParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3573 case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: {
3574 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3575 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3576 S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3577 CollapsedNum, Empty);
3581 case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: {
3582 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3583 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3584 S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3585 CollapsedNum, Empty);
3589 case STMT_OMP_TARGET_SIMD_DIRECTIVE: {
3590 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3591 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3592 S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3597 case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: {
3598 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3599 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3600 S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3601 CollapsedNum, Empty);
3605 case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3606 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3607 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3608 S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3609 CollapsedNum, Empty);
3613 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3614 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3615 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3616 S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(
3617 Context, NumClauses, CollapsedNum, Empty);
3621 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3622 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3623 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3624 S = OMPTeamsDistributeParallelForDirective::CreateEmpty(
3625 Context, NumClauses, CollapsedNum, Empty);
3629 case STMT_OMP_TARGET_TEAMS_DIRECTIVE: {
3630 S = OMPTargetTeamsDirective::CreateEmpty(
3631 Context, Record[ASTStmtReader::NumStmtFields], Empty);
3635 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: {
3636 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3637 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3638 S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3639 CollapsedNum, Empty);
3643 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3644 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3645 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3646 S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(
3647 Context, NumClauses, CollapsedNum, Empty);
3651 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3652 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3653 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3654 S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
3655 Context, NumClauses, CollapsedNum, Empty);
3659 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3660 auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3661 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3662 S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty(
3663 Context, NumClauses, CollapsedNum, Empty);
3667 case EXPR_CXX_OPERATOR_CALL:
3668 S = new (Context) CXXOperatorCallExpr(Context, Empty);
3671 case EXPR_CXX_MEMBER_CALL:
3672 S = new (Context) CXXMemberCallExpr(Context, Empty);
3675 case EXPR_CXX_CONSTRUCT:
3676 S = new (Context) CXXConstructExpr(Empty);
3679 case EXPR_CXX_INHERITED_CTOR_INIT:
3680 S = new (Context) CXXInheritedCtorInitExpr(Empty);
3683 case EXPR_CXX_TEMPORARY_OBJECT:
3684 S = new (Context) CXXTemporaryObjectExpr(Empty);
3687 case EXPR_CXX_STATIC_CAST:
3688 S = CXXStaticCastExpr::CreateEmpty(Context,
3689 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3692 case EXPR_CXX_DYNAMIC_CAST:
3693 S = CXXDynamicCastExpr::CreateEmpty(Context,
3694 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3697 case EXPR_CXX_REINTERPRET_CAST:
3698 S = CXXReinterpretCastExpr::CreateEmpty(Context,
3699 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3702 case EXPR_CXX_CONST_CAST:
3703 S = CXXConstCastExpr::CreateEmpty(Context);
3706 case EXPR_CXX_FUNCTIONAL_CAST:
3707 S = CXXFunctionalCastExpr::CreateEmpty(Context,
3708 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3711 case EXPR_USER_DEFINED_LITERAL:
3712 S = new (Context) UserDefinedLiteral(Context, Empty);
3715 case EXPR_CXX_STD_INITIALIZER_LIST:
3716 S = new (Context) CXXStdInitializerListExpr(Empty);
3719 case EXPR_CXX_BOOL_LITERAL:
3720 S = new (Context) CXXBoolLiteralExpr(Empty);
3723 case EXPR_CXX_NULL_PTR_LITERAL:
3724 S = new (Context) CXXNullPtrLiteralExpr(Empty);
3726 case EXPR_CXX_TYPEID_EXPR:
3727 S = new (Context) CXXTypeidExpr(Empty, true);
3729 case EXPR_CXX_TYPEID_TYPE:
3730 S = new (Context) CXXTypeidExpr(Empty, false);
3732 case EXPR_CXX_UUIDOF_EXPR:
3733 S = new (Context) CXXUuidofExpr(Empty, true);
3735 case EXPR_CXX_PROPERTY_REF_EXPR:
3736 S = new (Context) MSPropertyRefExpr(Empty);
3738 case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
3739 S = new (Context) MSPropertySubscriptExpr(Empty);
3741 case EXPR_CXX_UUIDOF_TYPE:
3742 S = new (Context) CXXUuidofExpr(Empty, false);
3745 S = new (Context) CXXThisExpr(Empty);
3747 case EXPR_CXX_THROW:
3748 S = new (Context) CXXThrowExpr(Empty);
3750 case EXPR_CXX_DEFAULT_ARG:
3751 S = new (Context) CXXDefaultArgExpr(Empty);
3753 case EXPR_CXX_DEFAULT_INIT:
3754 S = new (Context) CXXDefaultInitExpr(Empty);
3756 case EXPR_CXX_BIND_TEMPORARY:
3757 S = new (Context) CXXBindTemporaryExpr(Empty);
3760 case EXPR_CXX_SCALAR_VALUE_INIT:
3761 S = new (Context) CXXScalarValueInitExpr(Empty);
3764 S = new (Context) CXXNewExpr(Empty);
3766 case EXPR_CXX_DELETE:
3767 S = new (Context) CXXDeleteExpr(Empty);
3769 case EXPR_CXX_PSEUDO_DESTRUCTOR:
3770 S = new (Context) CXXPseudoDestructorExpr(Empty);
3773 case EXPR_EXPR_WITH_CLEANUPS:
3774 S = ExprWithCleanups::Create(Context, Empty,
3775 Record[ASTStmtReader::NumExprFields]);
3778 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
3779 S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
3780 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3781 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3782 ? Record[ASTStmtReader::NumExprFields + 1]
3786 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
3787 S = DependentScopeDeclRefExpr::CreateEmpty(Context,
3788 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3789 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3790 ? Record[ASTStmtReader::NumExprFields + 1]
3794 case EXPR_CXX_UNRESOLVED_CONSTRUCT:
3795 S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
3796 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3799 case EXPR_CXX_UNRESOLVED_MEMBER:
3800 S = UnresolvedMemberExpr::CreateEmpty(Context,
3801 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3802 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3803 ? Record[ASTStmtReader::NumExprFields + 1]
3807 case EXPR_CXX_UNRESOLVED_LOOKUP:
3808 S = UnresolvedLookupExpr::CreateEmpty(Context,
3809 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3810 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3811 ? Record[ASTStmtReader::NumExprFields + 1]
3815 case EXPR_TYPE_TRAIT:
3816 S = TypeTraitExpr::CreateDeserialized(Context,
3817 Record[ASTStmtReader::NumExprFields]);
3820 case EXPR_ARRAY_TYPE_TRAIT:
3821 S = new (Context) ArrayTypeTraitExpr(Empty);
3824 case EXPR_CXX_EXPRESSION_TRAIT:
3825 S = new (Context) ExpressionTraitExpr(Empty);
3828 case EXPR_CXX_NOEXCEPT:
3829 S = new (Context) CXXNoexceptExpr(Empty);
3832 case EXPR_PACK_EXPANSION:
3833 S = new (Context) PackExpansionExpr(Empty);
3836 case EXPR_SIZEOF_PACK:
3837 S = SizeOfPackExpr::CreateDeserialized(
3839 /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3842 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
3843 S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3846 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
3847 S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3850 case EXPR_FUNCTION_PARM_PACK:
3851 S = FunctionParmPackExpr::CreateEmpty(Context,
3852 Record[ASTStmtReader::NumExprFields]);
3855 case EXPR_MATERIALIZE_TEMPORARY:
3856 S = new (Context) MaterializeTemporaryExpr(Empty);
3860 S = new (Context) CXXFoldExpr(Empty);
3863 case EXPR_OPAQUE_VALUE:
3864 S = new (Context) OpaqueValueExpr(Empty);
3867 case EXPR_CUDA_KERNEL_CALL:
3868 S = new (Context) CUDAKernelCallExpr(Context, Empty);
3872 S = new (Context) AsTypeExpr(Empty);
3875 case EXPR_PSEUDO_OBJECT: {
3876 unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
3877 S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
3882 S = new (Context) AtomicExpr(Empty);
3886 unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
3887 S = LambdaExpr::CreateDeserialized(Context, NumCaptures);
3892 // We hit a STMT_STOP, so we're done with this expression.
3896 ++NumStatementsRead;
3898 if (S && !IsStmtReference) {
3900 StmtEntries[Cursor.GetCurrentBitNo()] = S;
3903 assert(Record.getIdx() == Record.size() &&
3904 "Invalid deserialization of statement");
3905 StmtStack.push_back(S);
3908 assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
3909 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
3910 return StmtStack.pop_back_val();