diff options
Diffstat (limited to 'lib/Serialization/ASTReaderStmt.cpp')
| -rw-r--r-- | lib/Serialization/ASTReaderStmt.cpp | 442 |
1 files changed, 387 insertions, 55 deletions
diff --git a/lib/Serialization/ASTReaderStmt.cpp b/lib/Serialization/ASTReaderStmt.cpp index 1115e8fd4f45..8bf17d51b3e8 100644 --- a/lib/Serialization/ASTReaderStmt.cpp +++ b/lib/Serialization/ASTReaderStmt.cpp @@ -176,7 +176,7 @@ void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) { (void)NumAttrs; assert(NumAttrs == S->NumAttrs); assert(NumAttrs == Attrs.size()); - std::copy(Attrs.begin(), Attrs.end(), S->Attrs); + std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr()); S->SubStmt = Reader.ReadSubStmt(); S->AttrLoc = ReadSourceLocation(Record, Idx); } @@ -202,7 +202,7 @@ void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) { if (Record[Idx++]) S->setAllEnumCasesCovered(); - SwitchCase *PrevSC = 0; + SwitchCase *PrevSC = nullptr; for (unsigned N = Record.size(); Idx != N; ++Idx) { SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]); if (PrevSC) @@ -399,13 +399,11 @@ void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) { S->getCapturedDecl()->setBody(S->getCapturedStmt()); // Captures - for (CapturedStmt::capture_iterator I = S->capture_begin(), - E = S->capture_end(); - I != E; ++I) { - I->VarAndKind.setPointer(ReadDeclAs<VarDecl>(Record, Idx)); - I->VarAndKind + for (auto &I : S->captures()) { + I.VarAndKind.setPointer(ReadDeclAs<VarDecl>(Record, Idx)); + I.VarAndKind .setInt(static_cast<CapturedStmt::VariableCaptureKind>(Record[Idx++])); - I->Loc = ReadSourceLocation(Record, Idx); + I.Loc = ReadSourceLocation(Record, Idx); } } @@ -718,7 +716,7 @@ void ASTStmtReader::VisitInitListExpr(InitListExpr *E) { E->setLBraceLoc(ReadSourceLocation(Record, Idx)); E->setRBraceLoc(ReadSourceLocation(Record, Idx)); bool isArrayFiller = Record[Idx++]; - Expr *filler = 0; + Expr *filler = nullptr; if (isArrayFiller) { filler = Reader.ReadSubExpr(); E->ArrayFillerOrUnionFieldInit = filler; @@ -1198,6 +1196,7 @@ void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { E->setElidable(Record[Idx++]); E->setHadMultipleCandidates(Record[Idx++]); E->setListInitialization(Record[Idx++]); + E->setStdInitListInitialization(Record[Idx++]); E->setRequiresZeroInitialization(Record[Idx++]); E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]); E->ParenOrBraceRange = ReadSourceRange(Record, Idx); @@ -1484,33 +1483,15 @@ void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx); } -void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { - VisitExpr(E); - E->UTT = (UnaryTypeTrait)Record[Idx++]; - E->Value = (bool)Record[Idx++]; - SourceRange Range = ReadSourceRange(Record, Idx); - E->Loc = Range.getBegin(); - E->RParen = Range.getEnd(); - E->QueriedType = GetTypeSourceInfo(Record, Idx); -} - -void ASTStmtReader::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { - VisitExpr(E); - E->BTT = (BinaryTypeTrait)Record[Idx++]; - E->Value = (bool)Record[Idx++]; - SourceRange Range = ReadSourceRange(Record, Idx); - E->Loc = Range.getBegin(); - E->RParen = Range.getEnd(); - E->LhsType = GetTypeSourceInfo(Record, Idx); - E->RhsType = GetTypeSourceInfo(Record, Idx); -} - void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) { VisitExpr(E); E->TypeTraitExprBits.NumArgs = Record[Idx++]; E->TypeTraitExprBits.Kind = Record[Idx++]; E->TypeTraitExprBits.Value = Record[Idx++]; - + SourceRange Range = ReadSourceRange(Record, Idx); + E->Loc = Range.getBegin(); + E->RParenLoc = Range.getEnd(); + TypeSourceInfo **Args = E->getTypeSourceInfos(); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) Args[I] = GetTypeSourceInfo(Record, Idx); @@ -1592,8 +1573,10 @@ void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { VisitExpr(E); - E->Temporary = Reader.ReadSubExpr(); - E->ExtendingDecl = ReadDeclAs<ValueDecl>(Record, Idx); + E->State = Reader.ReadSubExpr(); + auto VD = ReadDeclAs<ValueDecl>(Record, Idx); + unsigned ManglingNumber = Record[Idx++]; + E->setExtendingDecl(VD, ManglingNumber); } void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) { @@ -1627,6 +1610,11 @@ void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) { E->setExprOperand(Reader.ReadSubExpr()); } +void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) { + VisitStmt(S); + S->setLeaveLoc(ReadSourceLocation(Record, Idx)); +} + void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) { VisitStmt(S); S->Loc = ReadSourceLocation(Record, Idx); @@ -1691,18 +1679,72 @@ public: OMPClause *OMPClauseReader::readClause() { OMPClause *C; switch (Record[Idx++]) { + case OMPC_if: + C = new (Context) OMPIfClause(); + break; + case OMPC_final: + C = new (Context) OMPFinalClause(); + break; + case OMPC_num_threads: + C = new (Context) OMPNumThreadsClause(); + break; + case OMPC_safelen: + C = new (Context) OMPSafelenClause(); + break; + case OMPC_collapse: + C = new (Context) OMPCollapseClause(); + break; case OMPC_default: C = new (Context) OMPDefaultClause(); break; + case OMPC_proc_bind: + C = new (Context) OMPProcBindClause(); + break; + case OMPC_schedule: + C = new (Context) OMPScheduleClause(); + break; + case OMPC_ordered: + C = new (Context) OMPOrderedClause(); + break; + case OMPC_nowait: + C = new (Context) OMPNowaitClause(); + break; + case OMPC_untied: + C = new (Context) OMPUntiedClause(); + break; + case OMPC_mergeable: + C = new (Context) OMPMergeableClause(); + break; case OMPC_private: C = OMPPrivateClause::CreateEmpty(Context, Record[Idx++]); break; case OMPC_firstprivate: C = OMPFirstprivateClause::CreateEmpty(Context, Record[Idx++]); break; + case OMPC_lastprivate: + C = OMPLastprivateClause::CreateEmpty(Context, Record[Idx++]); + break; case OMPC_shared: C = OMPSharedClause::CreateEmpty(Context, Record[Idx++]); break; + case OMPC_reduction: + C = OMPReductionClause::CreateEmpty(Context, Record[Idx++]); + break; + case OMPC_linear: + C = OMPLinearClause::CreateEmpty(Context, Record[Idx++]); + break; + case OMPC_aligned: + C = OMPAlignedClause::CreateEmpty(Context, Record[Idx++]); + break; + case OMPC_copyin: + C = OMPCopyinClause::CreateEmpty(Context, Record[Idx++]); + break; + case OMPC_copyprivate: + C = OMPCopyprivateClause::CreateEmpty(Context, Record[Idx++]); + break; + case OMPC_flush: + C = OMPFlushClause::CreateEmpty(Context, Record[Idx++]); + break; } Visit(C); C->setLocStart(Reader->ReadSourceLocation(Record, Idx)); @@ -1711,6 +1753,31 @@ OMPClause *OMPClauseReader::readClause() { return C; } +void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) { + C->setCondition(Reader->Reader.ReadSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); +} + +void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) { + C->setCondition(Reader->Reader.ReadSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); +} + +void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) { + C->setNumThreads(Reader->Reader.ReadSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); +} + +void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) { + C->setSafelen(Reader->Reader.ReadSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); +} + +void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) { + C->setNumForLoops(Reader->Reader.ReadSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); +} + void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) { C->setDefaultKind( static_cast<OpenMPDefaultClauseKind>(Record[Idx++])); @@ -1718,6 +1785,30 @@ void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) { C->setDefaultKindKwLoc(Reader->ReadSourceLocation(Record, Idx)); } +void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) { + C->setProcBindKind( + static_cast<OpenMPProcBindClauseKind>(Record[Idx++])); + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setProcBindKindKwLoc(Reader->ReadSourceLocation(Record, Idx)); +} + +void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) { + C->setScheduleKind( + static_cast<OpenMPScheduleClauseKind>(Record[Idx++])); + C->setChunkSize(Reader->Reader.ReadSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setScheduleKindLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setCommaLoc(Reader->ReadSourceLocation(Record, Idx)); +} + +void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *) {} + +void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {} + +void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {} + +void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {} + void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) { C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); unsigned NumVars = C->varlist_size(); @@ -1738,6 +1829,16 @@ void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) { C->setVarRefs(Vars); } +void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) { + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + unsigned NumVars = C->varlist_size(); + SmallVector<Expr *, 16> Vars; + Vars.reserve(NumVars); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Reader.ReadSubExpr()); + C->setVarRefs(Vars); +} + void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) { C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); unsigned NumVars = C->varlist_size(); @@ -1748,12 +1849,82 @@ void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) { C->setVarRefs(Vars); } +void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) { + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); + NestedNameSpecifierLoc NNSL = + Reader->Reader.ReadNestedNameSpecifierLoc(Reader->F, Record, Idx); + DeclarationNameInfo DNI; + Reader->ReadDeclarationNameInfo(DNI, Record, Idx); + C->setQualifierLoc(NNSL); + C->setNameInfo(DNI); + + unsigned NumVars = C->varlist_size(); + SmallVector<Expr *, 16> Vars; + Vars.reserve(NumVars); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Reader.ReadSubExpr()); + C->setVarRefs(Vars); +} + +void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) { + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); + unsigned NumVars = C->varlist_size(); + SmallVector<Expr *, 16> Vars; + Vars.reserve(NumVars); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Reader.ReadSubExpr()); + C->setVarRefs(Vars); + C->setStep(Reader->Reader.ReadSubExpr()); +} + +void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) { + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); + unsigned NumVars = C->varlist_size(); + SmallVector<Expr *, 16> Vars; + Vars.reserve(NumVars); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Reader.ReadSubExpr()); + C->setVarRefs(Vars); + C->setAlignment(Reader->Reader.ReadSubExpr()); +} + +void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) { + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + unsigned NumVars = C->varlist_size(); + SmallVector<Expr *, 16> Vars; + Vars.reserve(NumVars); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Reader.ReadSubExpr()); + C->setVarRefs(Vars); +} + +void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) { + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + unsigned NumVars = C->varlist_size(); + SmallVector<Expr *, 16> Vars; + Vars.reserve(NumVars); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Reader.ReadSubExpr()); + C->setVarRefs(Vars); +} + +void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) { + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + unsigned NumVars = C->varlist_size(); + SmallVector<Expr *, 16> Vars; + Vars.reserve(NumVars); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Reader.ReadSubExpr()); + C->setVarRefs(Vars); +} + //===----------------------------------------------------------------------===// // OpenMP Directives. //===----------------------------------------------------------------------===// void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) { - VisitStmt(E); - ++Idx; E->setLocStart(ReadSourceLocation(Record, Idx)); E->setLocEnd(ReadSourceLocation(Record, Idx)); OMPClauseReader ClauseReader(this, Reader.getContext(), Record, Idx); @@ -1761,10 +1932,102 @@ void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) { for (unsigned i = 0; i < E->getNumClauses(); ++i) Clauses.push_back(ClauseReader.readClause()); E->setClauses(Clauses); - E->setAssociatedStmt(Reader.ReadSubStmt()); + if (E->hasAssociatedStmt()) + E->setAssociatedStmt(Reader.ReadSubStmt()); } void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) { + VisitStmt(D); + // The NumClauses field was read in ReadStmtFromStream. + ++Idx; + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) { + VisitStmt(D); + // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream. + Idx += 2; + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) { + VisitStmt(D); + // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream. + Idx += 2; + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) { + VisitStmt(D); + // The NumClauses field was read in ReadStmtFromStream. + ++Idx; + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) { + VisitStmt(D); + // The NumClauses field was read in ReadStmtFromStream. + ++Idx; + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); + ReadDeclarationNameInfo(D->DirName, Record, Idx); +} + +void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) { + VisitStmt(D); + // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream. + Idx += 2; + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPParallelSectionsDirective( + OMPParallelSectionsDirective *D) { + VisitStmt(D); + // The NumClauses field was read in ReadStmtFromStream. + ++Idx; + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) { + VisitStmt(D); + // The NumClauses field was read in ReadStmtFromStream. + ++Idx; + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) { + VisitStmt(D); + // The NumClauses field was read in ReadStmtFromStream. + ++Idx; VisitOMPExecutableDirective(D); } @@ -1826,7 +2089,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { case llvm::BitstreamEntry::SubBlock: // Handled for us already. case llvm::BitstreamEntry::Error: Error("malformed block record in AST file"); - return 0; + return nullptr; case llvm::BitstreamEntry::EndBlock: goto Done; case llvm::BitstreamEntry::Record: @@ -1834,8 +2097,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { break; } - - Stmt *S = 0; + Stmt *S = nullptr; Idx = 0; Record.clear(); bool Finished = false; @@ -1853,7 +2115,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { break; case STMT_NULL_PTR: - S = 0; + S = nullptr; break; case STMT_NULL: @@ -2044,7 +2306,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { S = MemberExpr::Create(Context, Base, IsArrow, QualifierLoc, TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo, - HasTemplateKWAndArgsInfo ? &ArgInfo : 0, + HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T, VK, OK); ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc, MemberD->getDeclName(), Record, Idx); @@ -2212,6 +2474,9 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { case EXPR_OBJC_BOOL_LITERAL: S = new (Context) ObjCBoolLiteralExpr(Empty); break; + case STMT_SEH_LEAVE: + S = new (Context) SEHLeaveStmt(Empty); + break; case STMT_SEH_EXCEPT: S = new (Context) SEHExceptStmt(Empty); break; @@ -2238,15 +2503,89 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { S = new (Context) MSDependentExistsStmt(SourceLocation(), true, NestedNameSpecifierLoc(), DeclarationNameInfo(), - 0); + nullptr); break; + case STMT_OMP_PARALLEL_DIRECTIVE: S = OMPParallelDirective::CreateEmpty(Context, Record[ASTStmtReader::NumStmtFields], Empty); break; - + + case STMT_OMP_SIMD_DIRECTIVE: { + unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; + unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPSimdDirective::CreateEmpty(Context, NumClauses, + CollapsedNum, Empty); + break; + } + + case STMT_OMP_FOR_DIRECTIVE: { + unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; + unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum, + Empty); + break; + } + + case STMT_OMP_SECTIONS_DIRECTIVE: + S = OMPSectionsDirective::CreateEmpty( + Context, Record[ASTStmtReader::NumStmtFields], Empty); + break; + + case STMT_OMP_SECTION_DIRECTIVE: + S = OMPSectionDirective::CreateEmpty(Context, Empty); + break; + + case STMT_OMP_SINGLE_DIRECTIVE: + S = OMPSingleDirective::CreateEmpty( + Context, Record[ASTStmtReader::NumStmtFields], Empty); + break; + + case STMT_OMP_MASTER_DIRECTIVE: + S = OMPMasterDirective::CreateEmpty(Context, Empty); + break; + + case STMT_OMP_CRITICAL_DIRECTIVE: + S = OMPCriticalDirective::CreateEmpty(Context, Empty); + break; + + case STMT_OMP_PARALLEL_FOR_DIRECTIVE: { + unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; + unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPParallelForDirective::CreateEmpty(Context, NumClauses, + CollapsedNum, Empty); + break; + } + + case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE: + S = OMPParallelSectionsDirective::CreateEmpty( + Context, Record[ASTStmtReader::NumStmtFields], Empty); + break; + + case STMT_OMP_TASK_DIRECTIVE: + S = OMPTaskDirective::CreateEmpty( + Context, Record[ASTStmtReader::NumStmtFields], Empty); + break; + + case STMT_OMP_TASKYIELD_DIRECTIVE: + S = OMPTaskyieldDirective::CreateEmpty(Context, Empty); + break; + + case STMT_OMP_BARRIER_DIRECTIVE: + S = OMPBarrierDirective::CreateEmpty(Context, Empty); + break; + + case STMT_OMP_TASKWAIT_DIRECTIVE: + S = OMPTaskwaitDirective::CreateEmpty(Context, Empty); + break; + + case STMT_OMP_FLUSH_DIRECTIVE: + S = OMPFlushDirective::CreateEmpty( + Context, Record[ASTStmtReader::NumStmtFields], Empty); + break; + case EXPR_CXX_OPERATOR_CALL: S = new (Context) CXXOperatorCallExpr(Context, Empty); break; @@ -2254,11 +2593,11 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { case EXPR_CXX_MEMBER_CALL: S = new (Context) CXXMemberCallExpr(Context, Empty); break; - + case EXPR_CXX_CONSTRUCT: S = new (Context) CXXConstructExpr(Empty); break; - + case EXPR_CXX_TEMPORARY_OBJECT: S = new (Context) CXXTemporaryObjectExpr(Empty); break; @@ -2327,7 +2666,8 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields]; if (HasOtherExprStored) { Expr *SubExpr = ReadSubExpr(); - S = CXXDefaultArgExpr::Create(Context, SourceLocation(), 0, SubExpr); + S = CXXDefaultArgExpr::Create(Context, SourceLocation(), nullptr, + SubExpr); } else S = new (Context) CXXDefaultArgExpr(Empty); break; @@ -2393,14 +2733,6 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { ? Record[ASTStmtReader::NumExprFields + 1] : 0); break; - - case EXPR_CXX_UNARY_TYPE_TRAIT: - S = new (Context) UnaryTypeTraitExpr(Empty); - break; - - case EXPR_BINARY_TYPE_TRAIT: - S = new (Context) BinaryTypeTraitExpr(Empty); - break; case EXPR_TYPE_TRAIT: S = TypeTraitExpr::CreateDeserialized(Context, @@ -2491,7 +2823,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { StmtStack.push_back(S); } Done: - assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!"); + assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!"); assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"); return StmtStack.pop_back_val(); } |