jdk8-mips64-public/nashorn: comparison src/jdk/nashorn/internal/codegen/Splitter.java

-:8af550dee961
+:6fc7b51e83d6
 import jdk.nashorn.internal.runtime.options.Options;
 /**
 * Split the IR into smaller compile units.
 */
-final class Splitter extends NodeVisitor {
+final class Splitter extends NodeVisitor<LexicalContext> {
 /** Current compiler. */
 private final Compiler compiler;
 /** IR to be broken down. */
-private FunctionNode outermost;
+private final FunctionNode outermost;
 /** Compile unit for the main script. */
 private final CompileUnit outermostCompileUnit;
 /** Cache for calculated block weights. */
 * @param compiler              the compiler
 * @param functionNode          function node to split
 * @param outermostCompileUnit  compile unit for outermost function, if non-lazy this is the script's compile unit
 */
 public Splitter(final Compiler compiler, final FunctionNode functionNode, final CompileUnit outermostCompileUnit) {
+super(new LexicalContext());
 this.compiler             = compiler;
 this.outermost            = functionNode;
 this.outermostCompileUnit = outermostCompileUnit;
 }
 LOG.finest("Postponing split of '", functionNode.getName(), "' as it's lazy");
 return functionNode;
 }
 LOG.finest("Initiating split of '", functionNode.getName(), "'");
-final LexicalContext lc = getLexicalContext();
 long weight = WeighNodes.weigh(functionNode);
 final boolean top = fn.isProgram(); //compiler.getFunctionNode() == outermost;
 if (weight >= SPLIT_THRESHOLD) {
 }
 final Block body = functionNode.getBody();
 final List<FunctionNode> dc = directChildren(functionNode);
-final Block newBody = (Block)body.accept(new NodeVisitor() {
+final Block newBody = (Block)body.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
 @Override
 public boolean enterFunctionNode(final FunctionNode nestedFunction) {
 return dc.contains(nestedFunction);
 }
 @Override
 public Node leaveFunctionNode(final FunctionNode nestedFunction) {
 FunctionNode split = new Splitter(compiler, nestedFunction, outermostCompileUnit).split(nestedFunction);
-getLexicalContext().replace(nestedFunction, split);
+lc.replace(nestedFunction, split);
 return split;
 }
 });
 functionNode = functionNode.setBody(lc, newBody);
 return functionNode.setState(lc, CompilationState.SPLIT);
 }
 private static List<FunctionNode> directChildren(final FunctionNode functionNode) {
 final List<FunctionNode> dc = new ArrayList<>();
-functionNode.accept(new NodeVisitor() {
+functionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
 @Override
 public boolean enterFunctionNode(final FunctionNode child) {
 if (child == functionNode) {
 return true;
 }
-if (getLexicalContext().getParentFunction(child) == functionNode) {
+if (lc.getParentFunction(child) == functionNode) {
 dc.add(child);
 }
 return false;
 }
 });
 * @param block Block or function to split.
 *
 * @return new weight for the resulting block.
 */
 private Block splitBlock(final Block block, final FunctionNode function) {
-getLexicalContext().setFlag(getLexicalContext().getCurrentFunction(), FunctionNode.IS_SPLIT);
+lc.setFlag(lc.getCurrentFunction(), FunctionNode.IS_SPLIT);
 final List<Statement> splits = new ArrayList<>();
 List<Statement> statements = new ArrayList<>();
 long statementsWeight = 0;
 if (!statements.isEmpty()) {
 splits.add(createBlockSplitNode(block, function, statements, statementsWeight));
 }
-return block.setStatements(getLexicalContext(), splits);
+return block.setStatements(lc, splits);
 }
 /**
 * Create a new split node from statements contained in a parent block.
 *
 // Block was heavier than SLIT_THRESHOLD in enter, but a sub-block may have
 // been split already, so weigh again before splitting.
 long weight = WeighNodes.weigh(block, weightCache);
 if (weight >= SPLIT_THRESHOLD) {
-newBlock = splitBlock(block, getLexicalContext().getFunction(block));
+newBlock = splitBlock(block, lc.getFunction(block));
 weight   = WeighNodes.weigh(newBlock, weightCache);
 }
 weightCache.put(newBlock, weight);
 return newBlock;
 }
 if (weight < SPLIT_THRESHOLD) {
 return literal;
 }
-final FunctionNode functionNode = getLexicalContext().getCurrentFunction();
+final FunctionNode functionNode = lc.getCurrentFunction();
-getLexicalContext().setFlag(functionNode, FunctionNode.IS_SPLIT);
+lc.setFlag(functionNode, FunctionNode.IS_SPLIT);
 if (literal instanceof ArrayLiteralNode) {
 final ArrayLiteralNode arrayLiteralNode = (ArrayLiteralNode) literal;
 final Node[]           value            = arrayLiteralNode.getValue();
 final int[]            postsets         = arrayLiteralNode.getPostsets();

Mercurial > jdk8-mips64-public > nashorn / file comparison

comparison: src/jdk/nashorn/internal/codegen/Splitter.java

src/jdk/nashorn/internal/codegen/Splitter.java