Start of checking for gotos which jump to an illegal destination.

As far as I know, this catches all cases of jumping into the scope of a 
variable with a variably modified type (excluding statement 
expressions) in C.  This is missing some stuff we probably want to check
(other kinds of variably modified declarations, statement expressions, 
indirect gotos/addresses of labels in a scope, ObjC @try/@finally, cleanup 
attribute), the diagnostics aren't very good, and it's not particularly 
efficient, but it's a decent start.

This patch is a slightly modified version of the patch I attached to
PR3259, and it fixes that bug.  I was sort of planning on improving 
it, but I think it's okay as-is, especially since it looks like CodeGen 
doesn't have any use for this sort of data structure.  The only 
significant change I can think of from the version I attached to PR3259 
is that this version skips running the checking code when a function 
doesn't contain any labels.

This patch doesn't cover case statements, which also need similar 
checking; I'm not sure how we should deal with that. Extending the goto 
checking to also check case statements wouldn't be too hard; it's just a 
matter of keeping track of the scope of the closest switch and checking that
the scope of every case is the same as the scope of the switch.  That said, 
it would likely be a performance hit to run this check on every 
function (it's an extra pass over the entire function), so we probably want
some other solution.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@65678 91177308-0d34-0410-b5e6-96231b3b80d8

include/clang/Basic/DiagnosticSemaKinds.def

@@ -744,6 +744,9 @@ DIAG(err_redefinition_of_label, ERROR,
 DIAG(err_undeclared_label_use, ERROR,
      "use of undeclared label '%0'")
 
+DIAG(err_goto_into_scope, ERROR,
+     "illegal jump (scoping violation)")
+
 DIAG(ext_implicit_function_decl, EXTENSION,
      "implicit declaration of function %0 is invalid in C99")
 

lib/Sema/Sema.h

@@ -383,6 +383,19 @@ public:
     return IdResolver.isDeclInScope(D, Ctx, Context, S);
   }
 
+
+  void RecursiveCalcJumpScopes(llvm::DenseMap<Stmt*, void*>& LabelScopeMap,
+                               llvm::DenseMap<void*, Stmt*>& PopScopeMap,
+                               llvm::DenseMap<Stmt*, void*>& GotoScopeMap,
+                               std::vector<void*>& ScopeStack,
+                               Stmt* CurStmt);
+
+  void RecursiveCalcLabelScopes(llvm::DenseMap<Stmt*, void*>& LabelScopeMap,
+                                llvm::DenseMap<void*, Stmt*>& PopScopeMap,
+                                std::vector<void*>& ScopeStack,
+                                Stmt* CurStmt,
+                                Stmt* ParentCompoundStmt);
+
   /// Subroutines of ActOnDeclarator().
   TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
                                 Decl *LastDecl);

lib/Sema/SemaDecl.cpp

@@ -2496,6 +2496,79 @@ Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclTy *D) {
   return FD;
 }
 
+static bool StatementCreatesScope(Stmt* S) {
+  bool result = false;
+  if (DeclStmt* DS = dyn_cast<DeclStmt>(S)) {
+    for (DeclStmt::decl_iterator i = DS->decl_begin();
+         i != DS->decl_end(); ++i) {
+      if (VarDecl* D = dyn_cast<VarDecl>(*i)) {
+        result |= D->getType()->isVariablyModifiedType();
+      }
+    }
+  }
+
+  return result;
+}
+
+void Sema::RecursiveCalcLabelScopes(llvm::DenseMap<Stmt*, void*>& LabelScopeMap,
+                                    llvm::DenseMap<void*, Stmt*>& PopScopeMap,
+                                    std::vector<void*>& ScopeStack,
+                                    Stmt* CurStmt,
+                                    Stmt* ParentCompoundStmt) {
+  for (Stmt::child_iterator i = CurStmt->child_begin();
+       i != CurStmt->child_end(); ++i) {
+    if (!*i) continue;
+    if (StatementCreatesScope(*i))  {
+      ScopeStack.push_back(*i);
+      PopScopeMap[*i] = ParentCompoundStmt;
+    } else if (isa<LabelStmt>(CurStmt)) {
+      LabelScopeMap[CurStmt] = ScopeStack.size() ? ScopeStack.back() : 0;
+    }
+    if (isa<DeclStmt>(*i)) continue;
+    Stmt* CurCompound = isa<CompoundStmt>(*i) ? *i : ParentCompoundStmt;
+    RecursiveCalcLabelScopes(LabelScopeMap, PopScopeMap, ScopeStack,
+                             *i, CurCompound);
+  }
+
+  while (ScopeStack.size() && PopScopeMap[ScopeStack.back()] == CurStmt) {
+    ScopeStack.pop_back();
+  }
+}
+
+void Sema::RecursiveCalcJumpScopes(llvm::DenseMap<Stmt*, void*>& LabelScopeMap,
+                                   llvm::DenseMap<void*, Stmt*>& PopScopeMap,
+                                   llvm::DenseMap<Stmt*, void*>& GotoScopeMap,
+                                   std::vector<void*>& ScopeStack,
+                                   Stmt* CurStmt) {
+  for (Stmt::child_iterator i = CurStmt->child_begin();
+       i != CurStmt->child_end(); ++i) {
+    if (!*i) continue;
+    if (StatementCreatesScope(*i))  {
+      ScopeStack.push_back(*i);
+    } else if (GotoStmt* GS = dyn_cast<GotoStmt>(*i)) {
+      void* LScope = LabelScopeMap[GS->getLabel()];
+      if (LScope) {
+        bool foundScopeInStack = false;
+        for (unsigned i = ScopeStack.size(); i > 0; --i) {
+          if (LScope == ScopeStack[i-1]) {
+            foundScopeInStack = true;
+            break;
+          }
+        }
+        if (!foundScopeInStack) {
+          Diag(GS->getSourceRange().getBegin(), diag::err_goto_into_scope);
+        }
+      }
+    }
+    if (isa<DeclStmt>(*i)) continue;
+    RecursiveCalcJumpScopes(LabelScopeMap, PopScopeMap, GotoScopeMap, ScopeStack, *i);
+  }
+
+  while (ScopeStack.size() && PopScopeMap[ScopeStack.back()] == CurStmt) {
+    ScopeStack.pop_back();
+  }
+}
+
 Sema::DeclTy *Sema::ActOnFinishFunctionBody(DeclTy *D, StmtArg BodyArg) {
   Decl *dcl = static_cast<Decl *>(D);
   Stmt *Body = static_cast<Stmt*>(BodyArg.release());
@@ -2511,7 +2584,8 @@ Sema::DeclTy *Sema::ActOnFinishFunctionBody(DeclTy *D, StmtArg BodyArg) {
   }
   PopDeclContext();
   // Verify and clean out per-function state.
-  
+
+  bool HaveLabels = !LabelMap.empty();
   // Check goto/label use.
   for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
        I = LabelMap.begin(), E = LabelMap.end(); I != E; ++I) {
@@ -2542,7 +2616,18 @@ Sema::DeclTy *Sema::ActOnFinishFunctionBody(DeclTy *D, StmtArg BodyArg) {
     }
   }
   LabelMap.clear();
-  
+
+  if (!Body) return D;
+
+  if (HaveLabels) {
+    llvm::DenseMap<Stmt*, void*> LabelScopeMap;
+    llvm::DenseMap<void*, Stmt*> PopScopeMap;
+    llvm::DenseMap<Stmt*, void*> GotoScopeMap;
+    std::vector<void*> ScopeStack;
+    RecursiveCalcLabelScopes(LabelScopeMap, PopScopeMap, ScopeStack, Body, Body);
+    RecursiveCalcJumpScopes(LabelScopeMap, PopScopeMap, GotoScopeMap, ScopeStack, Body);
+  }
+
   return D;
 }
 

test/Sema/scope-check.c

@@ -0,0 +1,8 @@
+// RUN: clang -fsyntax-only -verify %s
+
+int test1(int x) {
+  goto L; // expected-error{{illegal jump}}
+  int a[x];
+  L:
+  return sizeof a;
+}