Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ir.dataflow.analyses;
  
 
 import java.util.Map;
 import java.util.Set;
 
 // This problem tries to find places to insert binding stores -- for spilling local variables onto a heap store
 // It does better than spilling all local variables to the heap at all call sites.  This is similar to a
 // available expressions analysis in that it tries to propagate availability of stores through the flow graph.
 public class StoreLocalVarPlacementProblem extends DataFlowProblem {
     public static final String NAME = "Placement of local-var stores";
 
     private boolean scopeHasLocalVarStores;
     private boolean scopeHasUnrescuedExceptions;
 
     public StoreLocalVarPlacementProblem() {
         super(..);
     }
 
     public String getName() {
         return "Binding Stores Placement Analysis";
     }
 
     public FlowGraphNode buildFlowGraphNode(BasicBlock bb) {
         return new StoreLocalVarPlacementNode(thisbb);
     }
 
     @Override
     public String getDataFlowVarsForOutput() {
         return "";
     }
 
     public boolean scopeHasLocalVarStores() {
         return ;
     }
 
     public boolean scopeHasUnrescuedExceptions() {
         return ;
     }
 
     public void addStores(Map<OperandOperandvarRenameMap) {
         /* --------------------------------------------------------------------
          * If this is a closure, introduce a global ensure block that spills
          * into the binding the union of dirty vars from all call sites that
          * aren't protected by any other rescue or ensure block.
          *
          * This conservative scenario ensures that no matter what call site
          * we receive an exception from, when we exit the closure, all dirty
          * vars from the parent scope have been stored.
          * -------------------------------------------------------------------- */
         boolean mightRequireGlobalEnsureBlock = false;
 
         Set<LocalVariabledirtyVars = null;
 
         CFG     cfg      = getScope().cfg();
         IRScope cfgScope = cfg.getScope();
 
         this.      = false;
         this. = false;
 
         if (cfgScope instanceof IRClosure) {
             mightRequireGlobalEnsureBlock = true;
             dirtyVars = new HashSet<LocalVariable>();
         }
 
         // Add local-var stores
         for (FlowGraphNode n : ) {
             StoreLocalVarPlacementNode bspn = (StoreLocalVarPlacementNoden;
             boolean bbAddedStores;
             // SSS: This is highly conservative.  If the bb has an exception raising instr.
             // and we dont have a rescuer, only then do we have unrescued exceptions.
             // Right now, we are only checking for rescuers.
             boolean bbHasUnrescuedExceptions = !bspn.hasExceptionsRescued();
             if (mightRequireGlobalEnsureBlock && bbHasUnrescuedExceptions) {
                 bbAddedStores = bspn.addStores(varRenameMapdirtyVars);
             } else {
                 bbAddedStores = bspn.addStores(varRenameMapnull);
             }
 
              =  || bbHasUnrescuedExceptions;
                   =  || bbAddedStores;
         }
 
         // Allocate global-ensure block, if necessary
         BasicBlock geb = null;
        if ((mightRequireGlobalEnsureBlock == true) && !dirtyVars.isEmpty()) {
            Variable exc = cfgScope.getNewTemporaryVariable();
            geb = new BasicBlock(cfgnew Label("_GLOBAL_ENSURE_BLOCK"));
            geb.addInstr(new ReceiveExceptionInstr(excfalse)); // No need to check type since it is not used before rethrowing
            for (LocalVariable v : dirtyVars) {
                Operand value = varRenameMap.get(v);
                if (value == null) {
                    value = cfgScope.getNewTemporaryVariable("%t_" + v.getName());
                    varRenameMap.put(vvalue);
                }
                geb.addInstr(new StoreLocalVarInstr(value, (IRClosurecfgScopev));
            }
            geb.addInstr(new ThrowExceptionInstr(exc));
            cfg.addGlobalEnsureBB(geb);
        }
    }
New to GrepCode? Check out our FAQ X