jruby · Oct 27, 2014 · Oct 27, 2014 · Oct 27, 2014
Showing with 32 additions and 32 deletions.

+3 −1 core/src/main/java/org/jruby/ir/IRBuilder.java

+9 −16 core/src/main/java/org/jruby/ir/IRScope.java

+20 −15 core/src/main/java/org/jruby/ir/passes/AddCallProtocolInstructions.java
diff --git a/core/src/main/java/org/jruby/ir/IRBuilder.java b/core/src/main/java/org/jruby/ir/IRBuilder.java
@@ -2959,11 +2959,13 @@ public Operand buildPostExe(PostExeNode postExeNode, IRScope s) {
         closureBuilder.addInstr(endClosure, new CopyInstr(endClosure.getCurrentModuleVariable(), new ScopeModule(0)));
         closureBuilder.build(postExeNode.getBodyNode(), endClosure);
 
+        // Record to IRScope so JIT can pre-compile all potentially activated END blocks.
+        topLevel.recordEndBlock(endClosure);
+
         // Add an instruction in 's' to record the end block in the 'topLevel' scope.
         // SSS FIXME: IR support for end-blocks that access vars in non-toplevel-scopes
         // might be broken currently. We could either fix it or consider dropping support
         // for END blocks altogether or only support them in the toplevel. Not worth the pain.
-        s.recordEndBlock(endClosure);
         addInstr(s, new RecordEndBlockInstr(topLevel, new WrappedIRClosure(s.getSelf(), endClosure)));
         return manager.getNil();
     }

diff --git a/core/src/main/java/org/jruby/ir/IRScope.java b/core/src/main/java/org/jruby/ir/IRScope.java
@@ -527,22 +527,15 @@ protected Instr[] prepareInstructions() {
     }
 
     private boolean isUnsafeScope() {
-        boolean unsafeScope = false;
-        if (flags.contains(HAS_END_BLOCKS) || this.isBeginEndBlock()) {
-            unsafeScope = true;
-        } else {
-            List beginBlocks = this.getBeginBlocks();
-            // Ex: BEGIN {a = 1}; p a
-            if (beginBlocks == null || beginBlocks.isEmpty()) {
-                // Ex: eval("BEGIN {a = 1}; p a")
-                // Here, the BEGIN is added to the outer script scope.
-                beginBlocks = this.getNearestTopLocalVariableScope().getBeginBlocks();
-                unsafeScope = beginBlocks != null && !beginBlocks.isEmpty();
-            } else {
-                unsafeScope = true;
-            }
-        }
-        return unsafeScope;
+        if (this.isBeginEndBlock()) return true;                        // this is a BEGIN block
+
+        List beginBlocks = getBeginBlocks();
+        if (beginBlocks != null && !beginBlocks.isEmpty()) return true; // this contains a BEGIN block
+
+        // Does topmost variable scope contain any BEGIN blocks (IRScriptBody or IREval)?
+        // Ex1: eval("BEGIN {a = 1}; p a")    Ex2: BEGIN {a = 1}; p a
+        beginBlocks = getNearestTopLocalVariableScope().getBeginBlocks();
+        return beginBlocks != null && !beginBlocks.isEmpty();
     }
 
     public List<CompilerPass> getExecutedPasses() {

diff --git a/core/src/main/java/org/jruby/ir/passes/AddCallProtocolInstructions.java b/core/src/main/java/org/jruby/ir/passes/AddCallProtocolInstructions.java
@@ -57,21 +57,7 @@ public Object execute(IRScope scope, Object... data) {
                 scopeHasLocalVarStores = bindingHasEscaped;
             }
 
-            boolean requireFrame = bindingHasEscaped || scope.usesEval();
-
-            for (IRFlags flag : scope.getFlags()) {
-                switch (flag) {
-                    case BINDING_HAS_ESCAPED:
-                    case CAN_CAPTURE_CALLERS_BINDING:
-                    case REQUIRES_FRAME:
-                    case REQUIRES_VISIBILITY:
-                    case USES_BACKREF_OR_LASTLINE:
-                    case USES_EVAL:
-                    case USES_ZSUPER:
-                        requireFrame = true;
-                }
-            }
-
+            boolean requireFrame = doesItRequireFrame(scope, bindingHasEscaped);
             boolean requireBinding = !scope.getFlags().contains(IRFlags.DYNSCOPE_ELIMINATED);
 
             if (requireBinding || requireFrame) {
@@ -148,6 +134,25 @@ public Object execute(IRScope scope, Object... data) {
         return null;
     }
 
+    private boolean doesItRequireFrame(IRScope scope, boolean bindingHasEscaped) {
+        boolean requireFrame = bindingHasEscaped || scope.usesEval();
+
+        for (IRFlags flag : scope.getFlags()) {
+            switch (flag) {
+                case BINDING_HAS_ESCAPED:
+                case CAN_CAPTURE_CALLERS_BINDING:
+                case REQUIRES_FRAME:
+                case REQUIRES_VISIBILITY:
+                case USES_BACKREF_OR_LASTLINE:
+                case USES_EVAL:
+                case USES_ZSUPER:
+                    requireFrame = true;
+            }
+        }
+
+        return requireFrame;
+    }
+
     @Override
     public boolean invalidate(IRScope scope) {
         // Cannot add call protocol instructions after we've added them once.