| /* |
| * Copyright (c) 2010, 2013, 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. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * 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. |
| */ |
| |
| package jdk.nashorn.internal.codegen; |
| |
| import java.util.List; |
| import java.util.Map; |
| import jdk.nashorn.internal.ir.AccessNode; |
| import jdk.nashorn.internal.ir.BinaryNode; |
| import jdk.nashorn.internal.ir.Block; |
| import jdk.nashorn.internal.ir.BreakNode; |
| import jdk.nashorn.internal.ir.CallNode; |
| import jdk.nashorn.internal.ir.CatchNode; |
| import jdk.nashorn.internal.ir.ContinueNode; |
| import jdk.nashorn.internal.ir.ExpressionStatement; |
| import jdk.nashorn.internal.ir.ForNode; |
| import jdk.nashorn.internal.ir.FunctionNode; |
| import jdk.nashorn.internal.ir.IdentNode; |
| import jdk.nashorn.internal.ir.IfNode; |
| import jdk.nashorn.internal.ir.IndexNode; |
| import jdk.nashorn.internal.ir.JumpToInlinedFinally; |
| import jdk.nashorn.internal.ir.LexicalContext; |
| import jdk.nashorn.internal.ir.LiteralNode; |
| import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode; |
| import jdk.nashorn.internal.ir.Node; |
| import jdk.nashorn.internal.ir.ObjectNode; |
| import jdk.nashorn.internal.ir.PropertyNode; |
| import jdk.nashorn.internal.ir.ReturnNode; |
| import jdk.nashorn.internal.ir.RuntimeNode; |
| import jdk.nashorn.internal.ir.SplitNode; |
| import jdk.nashorn.internal.ir.Splittable; |
| import jdk.nashorn.internal.ir.SwitchNode; |
| import jdk.nashorn.internal.ir.ThrowNode; |
| import jdk.nashorn.internal.ir.TryNode; |
| import jdk.nashorn.internal.ir.UnaryNode; |
| import jdk.nashorn.internal.ir.VarNode; |
| import jdk.nashorn.internal.ir.WhileNode; |
| import jdk.nashorn.internal.ir.WithNode; |
| import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor; |
| |
| |
| /** |
| * Computes the "byte code" weight of an AST segment. This is used |
| * for Splitting too large class files |
| */ |
| final class WeighNodes extends NodeOperatorVisitor<LexicalContext> { |
| /* |
| * Weight constants. |
| */ |
| static final long FUNCTION_WEIGHT = 40; |
| static final long AASTORE_WEIGHT = 2; |
| static final long ACCESS_WEIGHT = 4; |
| static final long ADD_WEIGHT = 10; |
| static final long BREAK_WEIGHT = 1; |
| static final long CALL_WEIGHT = 10; |
| static final long CATCH_WEIGHT = 10; |
| static final long COMPARE_WEIGHT = 6; |
| static final long CONTINUE_WEIGHT = 1; |
| static final long IF_WEIGHT = 2; |
| static final long LITERAL_WEIGHT = 10; |
| static final long LOOP_WEIGHT = 4; |
| static final long NEW_WEIGHT = 6; |
| static final long FUNC_EXPR_WEIGHT = 20; |
| static final long RETURN_WEIGHT = 2; |
| static final long SPLIT_WEIGHT = 40; |
| static final long SWITCH_WEIGHT = 8; |
| static final long THROW_WEIGHT = 2; |
| static final long VAR_WEIGHT = 40; |
| static final long WITH_WEIGHT = 8; |
| static final long OBJECT_WEIGHT = 16; |
| static final long SETPROP_WEIGHT = 5; |
| |
| /** Accumulated weight. */ |
| private long weight; |
| |
| /** Optional cache for weight of block nodes. */ |
| private final Map<Node, Long> weightCache; |
| |
| private final FunctionNode topFunction; |
| |
| /** |
| * Constructor |
| * |
| * @param weightCache cache of already calculated block weights |
| */ |
| private WeighNodes(final FunctionNode topFunction, final Map<Node, Long> weightCache) { |
| super(new LexicalContext()); |
| this.topFunction = topFunction; |
| this.weightCache = weightCache; |
| } |
| |
| static long weigh(final Node node) { |
| return weigh(node, null); |
| } |
| |
| static long weigh(final Node node, final Map<Node, Long> weightCache) { |
| final WeighNodes weighNodes = new WeighNodes(node instanceof FunctionNode ? (FunctionNode)node : null, weightCache); |
| node.accept(weighNodes); |
| return weighNodes.weight; |
| } |
| |
| @Override |
| public Node leaveAccessNode(final AccessNode accessNode) { |
| weight += ACCESS_WEIGHT; |
| return accessNode; |
| } |
| |
| @Override |
| public boolean enterBlock(final Block block) { |
| if (weightCache != null && weightCache.containsKey(block)) { |
| weight += weightCache.get(block); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| @Override |
| public Node leaveBreakNode(final BreakNode breakNode) { |
| weight += BREAK_WEIGHT; |
| return breakNode; |
| } |
| |
| @Override |
| public Node leaveCallNode(final CallNode callNode) { |
| weight += CALL_WEIGHT; |
| return callNode; |
| } |
| |
| @Override |
| public Node leaveCatchNode(final CatchNode catchNode) { |
| weight += CATCH_WEIGHT; |
| return catchNode; |
| } |
| |
| @Override |
| public Node leaveContinueNode(final ContinueNode continueNode) { |
| weight += CONTINUE_WEIGHT; |
| return continueNode; |
| } |
| |
| @Override |
| public Node leaveExpressionStatement(final ExpressionStatement expressionStatement) { |
| return expressionStatement; |
| } |
| |
| @Override |
| public Node leaveForNode(final ForNode forNode) { |
| weight += LOOP_WEIGHT; |
| return forNode; |
| } |
| |
| @Override |
| public boolean enterFunctionNode(final FunctionNode functionNode) { |
| if (functionNode == topFunction) { |
| // the function being weighted; descend into its statements |
| return true; |
| } |
| // just a reference to inner function from outer function |
| weight += FUNC_EXPR_WEIGHT; |
| return false; |
| } |
| |
| @Override |
| public Node leaveIdentNode(final IdentNode identNode) { |
| weight += ACCESS_WEIGHT; |
| return identNode; |
| } |
| |
| @Override |
| public Node leaveIfNode(final IfNode ifNode) { |
| weight += IF_WEIGHT; |
| return ifNode; |
| } |
| |
| @Override |
| public Node leaveIndexNode(final IndexNode indexNode) { |
| weight += ACCESS_WEIGHT; |
| return indexNode; |
| } |
| |
| @Override |
| public Node leaveJumpToInlinedFinally(final JumpToInlinedFinally jumpToInlinedFinally) { |
| weight += BREAK_WEIGHT; |
| return jumpToInlinedFinally; |
| } |
| |
| @SuppressWarnings("rawtypes") |
| @Override |
| public boolean enterLiteralNode(final LiteralNode literalNode) { |
| weight += LITERAL_WEIGHT; |
| |
| if (literalNode instanceof ArrayLiteralNode) { |
| final ArrayLiteralNode arrayLiteralNode = (ArrayLiteralNode)literalNode; |
| final Node[] value = arrayLiteralNode.getValue(); |
| final int[] postsets = arrayLiteralNode.getPostsets(); |
| final List<Splittable.SplitRange> units = arrayLiteralNode.getSplitRanges(); |
| |
| if (units == null) { |
| for (final int postset : postsets) { |
| weight += AASTORE_WEIGHT; |
| final Node element = value[postset]; |
| |
| if (element != null) { |
| element.accept(this); |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| @Override |
| public boolean enterObjectNode(final ObjectNode objectNode) { |
| weight += OBJECT_WEIGHT; |
| final List<PropertyNode> properties = objectNode.getElements(); |
| final boolean isSpillObject = properties.size() > CodeGenerator.OBJECT_SPILL_THRESHOLD; |
| |
| for (final PropertyNode property : properties) { |
| if (!LiteralNode.isConstant(property.getValue())) { |
| weight += SETPROP_WEIGHT; |
| property.getValue().accept(this); |
| } else if (!isSpillObject) { |
| // constants in spill object are set via preset spill array, |
| // but fields objects need to set constants. |
| weight += SETPROP_WEIGHT; |
| } |
| |
| } |
| |
| return false; |
| } |
| |
| @Override |
| public Node leavePropertyNode(final PropertyNode propertyNode) { |
| weight += LITERAL_WEIGHT; |
| return propertyNode; |
| } |
| |
| @Override |
| public Node leaveReturnNode(final ReturnNode returnNode) { |
| weight += RETURN_WEIGHT; |
| return returnNode; |
| } |
| |
| @Override |
| public Node leaveRuntimeNode(final RuntimeNode runtimeNode) { |
| weight += CALL_WEIGHT; |
| return runtimeNode; |
| } |
| |
| @Override |
| public boolean enterSplitNode(final SplitNode splitNode) { |
| weight += SPLIT_WEIGHT; |
| return false; |
| } |
| |
| @Override |
| public Node leaveSwitchNode(final SwitchNode switchNode) { |
| weight += SWITCH_WEIGHT; |
| return switchNode; |
| } |
| |
| @Override |
| public Node leaveThrowNode(final ThrowNode throwNode) { |
| weight += THROW_WEIGHT; |
| return throwNode; |
| } |
| |
| @Override |
| public Node leaveTryNode(final TryNode tryNode) { |
| weight += THROW_WEIGHT; |
| return tryNode; |
| } |
| |
| @Override |
| public Node leaveVarNode(final VarNode varNode) { |
| weight += VAR_WEIGHT; |
| return varNode; |
| } |
| |
| @Override |
| public Node leaveWhileNode(final WhileNode whileNode) { |
| weight += LOOP_WEIGHT; |
| return whileNode; |
| } |
| |
| @Override |
| public Node leaveWithNode(final WithNode withNode) { |
| weight += WITH_WEIGHT; |
| return withNode; |
| } |
| |
| @Override |
| public Node leaveADD(final UnaryNode unaryNode) { |
| return unaryNodeWeight(unaryNode); |
| } |
| |
| @Override |
| public Node leaveBIT_NOT(final UnaryNode unaryNode) { |
| return unaryNodeWeight(unaryNode); |
| } |
| |
| @Override |
| public Node leaveDECINC(final UnaryNode unaryNode) { |
| return unaryNodeWeight(unaryNode); |
| } |
| |
| @Override |
| public Node leaveDELETE(final UnaryNode unaryNode) { |
| return runtimeNodeWeight(unaryNode); |
| } |
| |
| @Override |
| public Node leaveNEW(final UnaryNode unaryNode) { |
| weight += NEW_WEIGHT; |
| return unaryNode; |
| } |
| |
| @Override |
| public Node leaveNOT(final UnaryNode unaryNode) { |
| return unaryNodeWeight(unaryNode); |
| } |
| |
| @Override |
| public Node leaveSUB(final UnaryNode unaryNode) { |
| return unaryNodeWeight(unaryNode); |
| } |
| |
| @Override |
| public Node leaveTYPEOF(final UnaryNode unaryNode) { |
| return runtimeNodeWeight(unaryNode); |
| } |
| |
| @Override |
| public Node leaveVOID(final UnaryNode unaryNode) { |
| return unaryNodeWeight(unaryNode); |
| } |
| |
| @Override |
| public Node leaveADD(final BinaryNode binaryNode) { |
| weight += ADD_WEIGHT; |
| return binaryNode; |
| } |
| |
| @Override |
| public Node leaveAND(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_ADD(final BinaryNode binaryNode) { |
| weight += ADD_WEIGHT; |
| return binaryNode; |
| } |
| |
| @Override |
| public Node leaveASSIGN_BIT_AND(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_BIT_OR(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_BIT_XOR(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_DIV(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_MOD(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_MUL(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_SAR(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_SHL(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_SHR(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveASSIGN_SUB(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveBIND(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveBIT_AND(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveBIT_OR(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveBIT_XOR(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveCOMMALEFT(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveCOMMARIGHT(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveDIV(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveEQ(final BinaryNode binaryNode) { |
| return compareWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveEQ_STRICT(final BinaryNode binaryNode) { |
| return compareWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveGE(final BinaryNode binaryNode) { |
| return compareWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveGT(final BinaryNode binaryNode) { |
| return compareWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveIN(final BinaryNode binaryNode) { |
| weight += CALL_WEIGHT; |
| return binaryNode; |
| } |
| |
| @Override |
| public Node leaveINSTANCEOF(final BinaryNode binaryNode) { |
| weight += CALL_WEIGHT; |
| return binaryNode; |
| } |
| |
| @Override |
| public Node leaveLE(final BinaryNode binaryNode) { |
| return compareWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveLT(final BinaryNode binaryNode) { |
| return compareWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveMOD(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveMUL(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveNE(final BinaryNode binaryNode) { |
| return compareWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveNE_STRICT(final BinaryNode binaryNode) { |
| return compareWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveOR(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveSAR(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveSHL(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveSHR(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| @Override |
| public Node leaveSUB(final BinaryNode binaryNode) { |
| return binaryNodeWeight(binaryNode); |
| } |
| |
| private Node unaryNodeWeight(final UnaryNode unaryNode) { |
| weight += 1; |
| return unaryNode; |
| } |
| |
| private Node binaryNodeWeight(final BinaryNode binaryNode) { |
| weight += 1; |
| return binaryNode; |
| } |
| |
| private Node runtimeNodeWeight(final UnaryNode unaryNode) { |
| weight += CALL_WEIGHT; |
| return unaryNode; |
| } |
| |
| private Node compareWeight(final BinaryNode binaryNode) { |
| weight += COMPARE_WEIGHT; |
| return binaryNode; |
| } |
| } |
