From f82ff2549c0d3e123333cd1e68819dc7d98d375f Mon Sep 17 00:00:00 2001 From: Nico Weber Date: Mon, 9 Mar 2015 02:47:59 +0000 Subject: [PATCH] Warn when jumping out of a __finally block via continue, break, return, __leave. Since continue, break, return are much more common than __finally, this tries to keep the work for continue, break, return O(1). Sema keeps a stack of active __finally scopes (to do this, ActOnSEHFinally() is split into ActOnStartSEHFinally() and ActOnFinishSEHFinally()), and the various jump statements then check if the current __finally scope (if present) is deeper than then destination scope of the jump. The same warning for goto statements is still missing. This is the moral equivalent of MSVC's C4532. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@231623 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Basic/DiagnosticSemaKinds.td | 3 + include/clang/Sema/Scope.h | 6 ++ include/clang/Sema/Sema.h | 6 +- lib/Parse/ParseStmt.cpp | 7 +- lib/Sema/SemaStmt.cpp | 24 +++++-- lib/Sema/TreeTransform.h | 2 +- test/Sema/__try.c | 78 +++++++++++++++++++++- 7 files changed, 116 insertions(+), 10 deletions(-) diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 299844ecb9..226c5ec6ef 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -5490,6 +5490,9 @@ def err_mixing_cxx_try_seh_try : Error< "cannot use C++ 'try' in the same function as SEH '__try'">; def note_conflicting_try_here : Note< "conflicting %0 here">; +def warn_jump_out_of_seh_finally : Warning< + "jump out of __finally block has undefined behavior">, + InGroup>; def warn_non_virtual_dtor : Warning< "%0 has virtual functions but non-virtual destructor">, InGroup, DefaultIgnore; diff --git a/include/clang/Sema/Scope.h b/include/clang/Sema/Scope.h index cc6d9cca5b..238469a2d5 100644 --- a/include/clang/Sema/Scope.h +++ b/include/clang/Sema/Scope.h @@ -416,6 +416,12 @@ public: /// \brief Determine whether this scope is a SEH '__except' block. bool isSEHExceptScope() const { return getFlags() & Scope::SEHExceptScope; } + /// \brief Returns if rhs has a higher scope depth than this. + /// + /// The caller is responsible for calling this only if one of the two scopes + /// is an ancestor of the other. + bool Contains(const Scope& rhs) const { return Depth < rhs.Depth; } + /// containedInPrototypeScope - Return true if this or a parent scope /// is a FunctionPrototypeScope. bool containedInPrototypeScope() const; diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index 460111f522..9879ed9611 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -303,6 +303,9 @@ public: /// The stack always has at least one element in it. SmallVector VtorDispModeStack; + /// Stack of active SEH __finally scopes. Can be empty. + SmallVector CurrentSEHFinally; + /// \brief Source location for newly created implicit MSInheritanceAttrs SourceLocation ImplicitMSInheritanceAttrLoc; @@ -3293,7 +3296,8 @@ public: StmtResult ActOnSEHExceptBlock(SourceLocation Loc, Expr *FilterExpr, Stmt *Block); - StmtResult ActOnSEHFinallyBlock(SourceLocation Loc, Stmt *Block); + void ActOnStartSEHFinallyBlock(); + StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block); StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope); void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock); diff --git a/lib/Parse/ParseStmt.cpp b/lib/Parse/ParseStmt.cpp index e77f07ab03..9028e4ac2d 100644 --- a/lib/Parse/ParseStmt.cpp +++ b/lib/Parse/ParseStmt.cpp @@ -507,7 +507,7 @@ StmtResult Parser::ParseSEHExceptBlock(SourceLocation ExceptLoc) { /// seh-finally-block: /// '__finally' compound-statement /// -StmtResult Parser::ParseSEHFinallyBlock(SourceLocation FinallyBlock) { +StmtResult Parser::ParseSEHFinallyBlock(SourceLocation FinallyLoc) { PoisonIdentifierRAIIObject raii(Ident__abnormal_termination, false), raii2(Ident___abnormal_termination, false), raii3(Ident_AbnormalTermination, false); @@ -515,11 +515,14 @@ StmtResult Parser::ParseSEHFinallyBlock(SourceLocation FinallyBlock) { if (Tok.isNot(tok::l_brace)) return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace); + ParseScope FinallyScope(this, 0); + Actions.ActOnStartSEHFinallyBlock(); + StmtResult Block(ParseCompoundStatement()); if(Block.isInvalid()) return Block; - return Actions.ActOnSEHFinallyBlock(FinallyBlock,Block.get()); + return Actions.ActOnFinishSEHFinallyBlock(FinallyLoc, Block.get()); } /// Handle __leave diff --git a/lib/Sema/SemaStmt.cpp b/lib/Sema/SemaStmt.cpp index aaf29db702..11ec4f5321 100644 --- a/lib/Sema/SemaStmt.cpp +++ b/lib/Sema/SemaStmt.cpp @@ -2428,6 +2428,14 @@ Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc, return new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E); } +static void CheckJumpOutOfSEHFinally(Sema &S, SourceLocation Loc, + const Scope &DestScope) { + if (!S.CurrentSEHFinally.empty() && + DestScope.Contains(*S.CurrentSEHFinally.back())) { + S.Diag(Loc, diag::warn_jump_out_of_seh_finally); + } +} + StmtResult Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) { Scope *S = CurScope->getContinueParent(); @@ -2435,6 +2443,7 @@ Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) { // C99 6.8.6.2p1: A break shall appear only in or as a loop body. return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop)); } + CheckJumpOutOfSEHFinally(*this, ContinueLoc, *S); return new (Context) ContinueStmt(ContinueLoc); } @@ -2449,6 +2458,7 @@ Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) { if (S->isOpenMPLoopScope()) return StmtError(Diag(BreakLoc, diag::err_omp_loop_cannot_use_stmt) << "break"); + CheckJumpOutOfSEHFinally(*this, BreakLoc, *S); return new (Context) BreakStmt(BreakLoc); } @@ -2908,6 +2918,8 @@ Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, CurScope->setNoNRVO(); } + CheckJumpOutOfSEHFinally(*this, ReturnLoc, *CurScope->getFnParent()); + return R; } @@ -3406,11 +3418,14 @@ Sema::ActOnSEHExceptBlock(SourceLocation Loc, return SEHExceptStmt::Create(Context,Loc,FilterExpr,Block); } -StmtResult -Sema::ActOnSEHFinallyBlock(SourceLocation Loc, - Stmt *Block) { +void Sema::ActOnStartSEHFinallyBlock() { + CurrentSEHFinally.push_back(CurScope); +} + +StmtResult Sema::ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block) { assert(Block); - return SEHFinallyStmt::Create(Context,Loc,Block); + CurrentSEHFinally.pop_back(); + return SEHFinallyStmt::Create(Context, Loc, Block); } StmtResult @@ -3420,6 +3435,7 @@ Sema::ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope) { SEHTryParent = SEHTryParent->getParent(); if (!SEHTryParent) return StmtError(Diag(Loc, diag::err_ms___leave_not_in___try)); + CheckJumpOutOfSEHFinally(*this, Loc, *SEHTryParent); return new (Context) SEHLeaveStmt(Loc); } diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index e1d0d18dde..351dacd256 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -1702,7 +1702,7 @@ public: } StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) { - return getSema().ActOnSEHFinallyBlock(Loc, Block); + return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block); } /// \brief Build a new predefined expression. diff --git a/test/Sema/__try.c b/test/Sema/__try.c index 0e5de2018d..925dbcc55e 100644 --- a/test/Sema/__try.c +++ b/test/Sema/__try.c @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -fborland-extensions -DBORLAND -fsyntax-only -verify %s -// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify %s +// RUN: %clang_cc1 -fborland-extensions -DBORLAND -fsyntax-only -verify -fblocks %s +// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify -fblocks %s #define JOIN2(x,y) x ## y #define JOIN(x,y) JOIN2(x,y) @@ -207,3 +207,77 @@ void test_seh_leave_stmt() { } __leave; // expected-error{{'__leave' statement not in __try block}} } + +void test_jump_out_of___finally() { + while(1) { + __try { + } __finally { + continue; // expected-warning{{jump out of __finally block has undefined behavior}} + } + } + __try { + } __finally { + while (1) { + continue; + } + } + + // Check that a deep __finally containing a block with a shallow continue + // doesn't trigger the warning. + while(1) {{{{ + __try { + } __finally { + ^{ + while(1) + continue; + }(); + } + }}}} + + while(1) { + __try { + } __finally { + break; // expected-warning{{jump out of __finally block has undefined behavior}} + } + } + switch(1) { + case 1: + __try { + } __finally { + break; // expected-warning{{jump out of __finally block has undefined behavior}} + } + } + __try { + } __finally { + while (1) { + break; + } + } + + __try { + __try { + } __finally { + __leave; // expected-warning{{jump out of __finally block has undefined behavior}} + } + } __finally { + } + __try { + } __finally { + __try { + __leave; + } __finally { + } + } + + __try { + } __finally { + return; // expected-warning{{jump out of __finally block has undefined behavior}} + } + + __try { + } __finally { + ^{ + return; + }(); + } +} -- 2.40.0