8067429: java.lang.VerifyError: Inconsistent stackmap frames at branch target

Summary: bitset for alive variables contains info about variables out of range
Reviewed-by: mcimadamore
Contributed-by: srikanth.adayapalam@oracle.com

src/share/classes/com/sun/tools/javac/jvm/Gen.java

@@ -1222,9 +1222,10 @@ public class Gen extends JCTree.Visitor {
                 code.resolve(c.jumpTrue(), startpc);
                 code.resolve(c.falseJumps);
             }
-            code.resolve(loopEnv.info.exit);
-            if (loopEnv.info.exit != null) {
-                loopEnv.info.exit.state.defined.excludeFrom(code.nextreg);
+            Chain exit = loopEnv.info.exit;
+            if (exit != null) {
+                code.resolve(exit);
+                exit.state.defined.excludeFrom(code.nextreg);
             }
         }
 
@@ -1235,7 +1236,11 @@ public class Gen extends JCTree.Visitor {
     public void visitLabelled(JCLabeledStatement tree) {
         Env<GenContext> localEnv = env.dup(tree, new GenContext());
         genStat(tree.body, localEnv, CRT_STATEMENT);
-        code.resolve(localEnv.info.exit);
+        Chain exit = localEnv.info.exit;
+        if (exit != null) {
+            code.resolve(exit);
+            exit.state.defined.excludeFrom(code.nextreg);
+        }
     }
 
     public void visitSwitch(JCSwitch tree) {
@@ -1344,7 +1349,11 @@ public class Gen extends JCTree.Visitor {
             }
 
             // Resolve all breaks.
-            code.resolve(switchEnv.info.exit);
+            Chain exit = switchEnv.info.exit;
+            if  (exit != null) {
+                code.resolve(exit);
+                exit.state.defined.excludeFrom(code.nextreg);
+            }
 
             // If we have not set the default offset, we do so now.
             if (code.get4(tableBase) == -1) {

test/tools/javac/BranchToFewerDefines.java

+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8067429
+ * @summary java.lang.VerifyError: Inconsistent stackmap frames at branch target
+ * @author srikanth
+ *
+ * @compile  BranchToFewerDefines.java
+ * @run main BranchToFewerDefines
+ */
+
+public class BranchToFewerDefines {
+        public static void main(String[] args) {
+        }
+        private void problematicMethod(int p) {
+                switch (p) {
+                        case 3:
+                                long n;
+                                while (true) {
+                                        if (false) {
+                                                break;
+                                        }
+                                }
+                                break;
+                        case 2:
+                                loop: while (true) {
+                                        while (true) {
+                                                int i = 4;
+                                                if (p != 16) {
+                                                        return;
+                                                }
+                                                break loop;
+                                        }
+                                }
+                                break;
+                        default:
+                                while (true) {
+                                        if (false) {
+                                                break;
+                                        }
+                                }
+                                break;
+                }
+                long b;
+                if (p != 7) {
+                        switch (p) {
+                                case 1:
+                                        long a = 17;
+                                        break;
+                                case 2:
+                                        break;
+                                default:
+                                        break;
+                        }
+                }
+        }
+        private void problematicMethod2(int p) {
+                switch (p) {
+                        case 3:
+                                long n;
+                                {
+                                        int i = 4;
+                                        break;
+                                }
+                        case 2:
+                                {
+                                        int i = 4;
+                                        break;
+                                }
+                        default:
+                                {
+                                        int i = 4;
+                                        break;
+                                }
+                }
+                long b;
+                if (p != 7) {
+                        switch (p) {
+                                case 1:
+                                        long a = 17;
+                                        break;
+                                case 2:
+                                        break;
+                                default:
+                                        break;
+                        }
+                }
+        }
+}