Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ir.passes;
  
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
 
 public class LocalOptimizationPass extends CompilerPass {
     boolean locallyOptimized = false;
 
     public static List<Class<? extends CompilerPass>> DEPENDENCIES = Arrays.<Class<? extends CompilerPass>>asList(CFGBuilder.class);
 
     @Override
     public String getLabel() {
         return "Local Optimizations";
     }
 
     @Override
     public List<Class<? extends CompilerPass>> getDependencies() {
         return ;
     }
 
     @Override
     public Object execute(IRScope sObject... data) {
         // This let us compute execute scope flags for a method based on what all nested closures do
         for (IRClosure cs.getClosures()) {
             run(ctrue);
         }
 
         for (BasicBlock b: ((CFGdata[0]).getBasicBlocks()) {
             runLocalOptsOnInstrList(sb.getInstrs().listIterator(), false);
         }
 
         // Only after running local opts, compute various execution scope flags
         s.computeScopeFlags();
 
         // Mark done
          = true;
 
         return null;
     }
 
     @Override
     public Object previouslyRun(IRScope scope) {
         return  ? new Object() : null;
     }
 
     @Override
     public void invalidate(IRScope scope) {
          = false;
     }
 
     private static void recordSimplification(Variable resOperand valMap<OperandOperandvalueMapMap<VariableList<Variable>> simplificationMap) {
         valueMap.put(resval);
 
         // For all variables used by val, record a reverse mapping to let us track
         // Read-After-Write scenarios when any of these variables are modified.
         List<VariablevalVars = new ArrayList<Variable>();
         val.addUsedVariables(valVars);
         for (Variable vvalVars) {
            List<Variablex = simplificationMap.get(v);
            if (x == null) {
               x = new ArrayList<Variable>();
               simplificationMap.put(vx);
            }
            x.add(res);
         }
     }
 
     public static void runLocalOptsOnInstrList(IRScope sListIterator<Instrinstrsboolean preCFG) {
         // Reset value map if this instruction is the start/end of a basic block
         //
         // Right now, calls are considered hard boundaries for optimization and
         // information cannot be propagated across them!
         //
         // SSS FIXME: Rather than treat all calls with a broad brush, what we need
         // is to capture different attributes about a call :
         //   - uses closures
         //   - known call target
         //   - can modify scope,
         //   - etc.
         //
         // This information is probably already present in the AST Inspector
         Map<Operand,OperandvalueMap = new HashMap<Operand,Operand>();
         Map<Variable,List<Variable>> simplificationMap = new HashMap<Variable,List<Variable>>();
         while (instrs.hasNext()) {
             Instr i = instrs.next();
            Operation iop = i.getOperation();
            if (preCFG && iop.startsBasicBlock()) {
                valueMap = new HashMap<Operand,Operand>();
                simplificationMap = new HashMap<Variable,List<Variable>>();
            }
            // Simplify instruction and record mapping between target variable and simplified value
            // System.out.println("BEFORE: " + i);
            Operand  val = i.simplifyAndGetResult(svalueMap);
            // FIXME: This logic can be simplified based on the number of res != null checks only done if doesn't
            Variable res = i instanceof ResultInstr ? ((ResultInstri).getResult() : null;
            // System.out.println("For " + i + "; dst = " + res + "; val = " + val);
            // System.out.println("AFTER: " + i);
            if (res != null && val != null) {
                if (!res.equals(val)) {
                    recordSimplification(resvalvalueMapsimplificationMap);
                } else if (!i.hasSideEffects()) {
                    if (i instanceof CopyInstr) {
                        if (i.canBeDeleted(s)) {
                            i.markDead();
                            instrs.remove();
                        }
                    } else {
                        instrs.set(new CopyInstr(resval));
                    }
                }
            } else if (res != null && val == null) {
                // If we didn't get a simplified value, remove any existing simplifications for the result
                // to get rid of RAW hazards!
                valueMap.remove(res);
            }
            // Purge all entries in valueMap that have 'res' as their simplified value to take care of RAW scenarios (because we aren't in SSA form yet!)
            if ((res != null) && !res.equals(val)) {
                List<VariablesimplifiedVars = simplificationMap.get(res);
                if (simplifiedVars != null) {
                    for (Variable vsimplifiedVars) {
                        valueMap.remove(v);
                    }
                    simplificationMap.remove(res);
                }
            }
            // If the call has been optimized away in the previous step, it is no longer a hard boundary for opts!
            if ((preCFG && iop.endsBasicBlock()) || (iop.isCall() && !i.isDead())) {
                valueMap = new HashMap<Operand,Operand>();
                simplificationMap = new HashMap<Variable,List<Variable>>();
            }
        }
    }
New to GrepCode? Check out our FAQ X