| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package org.apache.flex.abc.semantics; |
| |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import static org.apache.flex.abc.ABCConstants.*; |
| import org.apache.flex.abc.graph.IBasicBlock; |
| import org.apache.flex.abc.graph.IFlowgraph; |
| import org.apache.flex.abc.visitors.IDiagnosticsVisitor; |
| import org.apache.flex.abc.visitors.IFlowGraphVisitor; |
| |
| /** |
| * A FrameCountVisitor tracks the stack, scope, local, and slot numbers |
| * encountered in a method body, so that the MethodBodyInfo can set its |
| * max_stack, max_scope, max_local, and max_slot values. |
| */ |
| public class FrameCountVisitor implements IFlowGraphVisitor |
| { |
| /** |
| * Construct a new FrameCountVisitor. |
| * |
| * @param mbi - the MethodBodyInfo to analyze. |
| * @param diagnosticsVisitor - a sink for diagnostics. |
| * @param initial_scope - caller's a priori initial scope depth. |
| */ |
| FrameCountVisitor(MethodBodyInfo mbi, IDiagnosticsVisitor diagnosticsVisitor, int initial_scope) |
| { |
| this.diagnosticsVisitor = diagnosticsVisitor; |
| this.cfg = mbi.getCfg(); |
| this.mbi = mbi; |
| this.initial_scope = initial_scope; |
| this.exceptions = mbi.getExceptions(); |
| this.instructionIndex = 0; |
| } |
| |
| /** |
| * The MethodBodyInfo that generated the IFlowgraph. |
| */ |
| final MethodBodyInfo mbi; |
| |
| /** |
| * Receiver of any diagnostic output. |
| */ |
| final IDiagnosticsVisitor diagnosticsVisitor; |
| |
| /** |
| * The control flow graph, denormalized from the MethodBodyInfo. |
| */ |
| final IFlowgraph cfg; |
| |
| /** |
| * Caller's a priori initial scope depth. |
| */ |
| final int initial_scope; |
| |
| /** |
| * Exception information from the method body. |
| */ |
| final Iterable<ExceptionInfo> exceptions; |
| |
| int max_stack; |
| int max_local; |
| int max_scope; |
| int max_slot; |
| |
| /** |
| * Set if we encounter a newclass instruction. |
| */ |
| boolean hasNewclass = false; |
| |
| /** |
| * Stack depths on entry to blocks |
| */ |
| Map<IBasicBlock, Integer> stkin = new HashMap<IBasicBlock, Integer>(); |
| |
| /** |
| * Scope depths on entry to blocks |
| */ |
| Map<IBasicBlock, Integer> scpin = new HashMap<IBasicBlock, Integer>(); |
| |
| int stkdepth = 0; |
| int scpdepth = 0; |
| |
| int instructionIndex; |
| |
| IBasicBlock currentBlock; |
| |
| /** |
| * Visit a new Block. |
| * |
| * @param b - the Block to visit. |
| * @return true if the walker should continue visiting the block. |
| */ |
| public boolean visitBlock(IBasicBlock b) |
| { |
| this.currentBlock = b; |
| |
| if (this.cfg.isCatchTarget(b)) |
| { |
| stkdepth = 1; |
| scpdepth = 0; |
| } |
| else if (stkin.containsKey(b)) |
| { |
| stkdepth = stkin.get(b); |
| scpdepth = scpin.get(b); |
| } |
| // else use the current values. |
| return true; |
| } |
| |
| /** |
| * Visit an Instruction within the most recently-visited Block. |
| * |
| * @param i - the Instruction. |
| */ |
| public void visitInstruction(Instruction i) |
| { |
| switch (i.opcode) |
| { |
| case OP_add: |
| case OP_add_i: |
| case OP_astypelate: |
| case OP_bitand: |
| case OP_bitor: |
| case OP_bitxor: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| |
| case OP_applytype: |
| case OP_astype: |
| case OP_bitnot: |
| case OP_bkpt: |
| case OP_bkptline: |
| case OP_checkfilter: |
| case OP_coerce: |
| case OP_coerce_a: |
| case OP_coerce_i: |
| case OP_coerce_d: |
| case OP_coerce_s: |
| case OP_coerce_u: |
| case OP_convert_b: |
| case OP_convert_d: |
| case OP_convert_i: |
| case OP_convert_o: |
| case OP_convert_s: |
| case OP_convert_u: |
| case OP_debug: |
| case OP_debugfile: |
| case OP_debugline: |
| case OP_declocal: |
| case OP_declocal_i: |
| case OP_decrement: |
| case OP_decrement_i: |
| case OP_dxns: |
| case OP_esc_xattr: |
| case OP_esc_xelem: |
| case OP_inclocal: |
| case OP_inclocal_i: |
| case OP_increment: |
| case OP_increment_i: |
| case OP_jump: |
| case OP_kill: |
| case OP_label: |
| case OP_negate: |
| case OP_negate_i: |
| case OP_returnvoid: |
| case OP_nop: |
| case OP_not: |
| case OP_swap: |
| case OP_timestamp: |
| case OP_typeof: |
| case OP_unplus: |
| // Net effect zero. |
| break; |
| |
| case OP_call: |
| stkdepth = adjustValueStack(stkdepth, -(i.getImmediate() + 1)); |
| break; |
| |
| case OP_callmethod: |
| assert false : "internal only instruction!"; |
| stkdepth = adjustValueStack(stkdepth, -i.getImmediate()); |
| break; |
| |
| case OP_callstatic: |
| stkdepth = adjustValueStack(stkdepth, -((Integer)i.getOperand(1))); |
| break; |
| |
| case OP_callproperty: |
| case OP_callproplex: |
| case OP_callsuper: |
| case OP_constructprop: |
| stkdepth = adjustValueStack(stkdepth, -((Integer)i.getOperand(1)) + runtimeNameAllowance((Name)i.getOperand(0))); |
| break; |
| |
| case OP_callpropvoid: |
| case OP_callsupervoid: |
| // void calls do not push a result |
| stkdepth = adjustValueStack(stkdepth, -((Integer)i.getOperand(1)) + runtimeNameAllowance((Name)i.getOperand(0)) - 1); |
| break; |
| |
| case OP_construct: |
| stkdepth = adjustValueStack(stkdepth, -i.getImmediate()); |
| break; |
| |
| case OP_constructsuper: |
| stkdepth = adjustValueStack(stkdepth, -i.getImmediate() - 1); |
| break; |
| |
| case OP_deleteproperty: |
| stkdepth = adjustValueStack(stkdepth, runtimeNameAllowance((Name)i.getOperand(0))); |
| break; |
| |
| case OP_divide: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| case OP_dup: |
| stkdepth = adjustValueStack(stkdepth, 1); |
| break; |
| case OP_dxnslate: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| case OP_equals: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| case OP_finddef: |
| case OP_findproperty: |
| case OP_findpropstrict: |
| stkdepth = adjustValueStack(stkdepth, 1 + runtimeNameAllowance((Name)i.getOperand(0))); |
| break; |
| |
| case OP_getdescendants: |
| case OP_getproperty: |
| case OP_getsuper: |
| stkdepth = adjustValueStack(stkdepth, runtimeNameAllowance((Name)i.getOperand(0))); |
| break; |
| |
| case OP_getglobalscope: |
| case OP_getglobalslot: |
| case OP_getlex: |
| case OP_getouterscope: |
| stkdepth = adjustValueStack(stkdepth, 1); |
| break; |
| |
| case OP_getlocal: |
| stkdepth = adjustValueStack(stkdepth, 1); |
| adjustMaxLocal(i.getImmediate()); |
| if (i.getImmediate() < 4) |
| i.opcode = OP_getlocal0 + i.getImmediate(); |
| break; |
| case OP_getlocal0: |
| case OP_getlocal1: |
| case OP_getlocal2: |
| case OP_getlocal3: |
| stkdepth = adjustValueStack(stkdepth, 1); |
| adjustMaxLocal(i.opcode - OP_getlocal0); |
| break; |
| |
| case OP_getslot: |
| if (i.getImmediate() > max_slot) |
| max_slot = i.getImmediate(); |
| break; |
| |
| case OP_getscopeobject: |
| stkdepth = adjustValueStack(stkdepth, 1); |
| break; |
| |
| case OP_greaterequals: |
| case OP_greaterthan: |
| case OP_hasnext: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| case OP_hasnext2: |
| { |
| // Both hasnext2 operands are locals. |
| adjustMaxLocal((Integer)i.getOperand(0)); |
| adjustMaxLocal((Integer)i.getOperand(1)); |
| stkdepth = adjustValueStack(stkdepth, 1); |
| break; |
| } |
| case OP_ifeq: |
| case OP_ifge: |
| case OP_ifgt: |
| case OP_ifle: |
| case OP_iflt: |
| case OP_ifnge: |
| case OP_ifngt: |
| case OP_ifnle: |
| case OP_ifnlt: |
| case OP_ifne: |
| case OP_ifstricteq: |
| case OP_ifstrictne: |
| stkdepth = adjustValueStack(stkdepth, -2); |
| break; |
| case OP_iffalse: |
| case OP_iftrue: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| |
| case OP_in: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| |
| case OP_initproperty: |
| stkdepth = adjustValueStack(stkdepth, -2 + runtimeNameAllowance((Name)i.getOperand(0))); |
| break; |
| |
| case OP_instanceof: |
| case OP_istypelate: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| |
| case OP_istype: |
| stkdepth = adjustValueStack(stkdepth, runtimeNameAllowance((Name)i.getOperand(0))); |
| break; |
| |
| case OP_lessequals: |
| case OP_lessthan: |
| case OP_lookupswitch: |
| case OP_lshift: |
| case OP_modulo: |
| case OP_multiply: |
| case OP_multiply_i: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| |
| case OP_newactivation: |
| case OP_newcatch: |
| case OP_newfunction: |
| stkdepth = adjustValueStack(stkdepth, 1); |
| break; |
| |
| case OP_newarray: |
| stkdepth = adjustValueStack(stkdepth, 1 - i.getImmediate()); |
| break; |
| |
| case OP_newobject: |
| // The operands are name-value pairs. |
| stkdepth = adjustValueStack(stkdepth, 1 - (i.getImmediate() * 2)); |
| break; |
| |
| case OP_nextname: |
| case OP_nextvalue: |
| case OP_pop: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| |
| case OP_popscope: |
| scpdepth = adjustScopeStack(scpdepth, -1); |
| break; |
| |
| case OP_pushbyte: |
| case OP_pushdouble: |
| case OP_pushfalse: |
| case OP_pushint: |
| case OP_pushnamespace: |
| case OP_pushnan: |
| case OP_pushnull: |
| case OP_pushshort: |
| case OP_pushstring: |
| case OP_pushtrue: |
| case OP_pushuint: |
| case OP_pushundefined: |
| stkdepth = adjustValueStack(stkdepth, 1); |
| break; |
| |
| case OP_pushscope: |
| case OP_pushwith: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| scpdepth = adjustScopeStack(scpdepth, 1); |
| break; |
| |
| case OP_returnvalue: |
| case OP_rshift: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| |
| case OP_setlocal: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| adjustMaxLocal(i.getImmediate()); |
| if (i.getImmediate() < 4) |
| i.opcode = OP_setlocal0 + i.getImmediate(); |
| break; |
| case OP_setlocal0: |
| case OP_setlocal1: |
| case OP_setlocal2: |
| case OP_setlocal3: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| adjustMaxLocal(i.opcode - OP_setlocal0); |
| break; |
| |
| case OP_setglobalslot: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| |
| case OP_setproperty: |
| case OP_setsuper: |
| stkdepth = adjustValueStack(stkdepth, -2 + runtimeNameAllowance((Name)i.getOperand(0))); |
| break; |
| |
| case OP_setslot: |
| stkdepth = adjustValueStack(stkdepth, -2); |
| if (max_slot < i.getImmediate()) |
| max_slot = i.getImmediate(); |
| break; |
| |
| case OP_strictequals: |
| case OP_subtract: |
| case OP_subtract_i: |
| case OP_throw: |
| case OP_urshift: |
| stkdepth = adjustValueStack(stkdepth, -1); |
| break; |
| |
| case OP_newclass: |
| this.hasNewclass = true; |
| break; |
| |
| case OP_li8: |
| case OP_li16: |
| case OP_li32: |
| case OP_lf32: |
| case OP_lf64: |
| case OP_sxi1: |
| case OP_sxi8: |
| case OP_sxi16: |
| // consume one stack entry, and produce 1 stack entry. |
| break; |
| case OP_si8: |
| case OP_si16: |
| case OP_si32: |
| case OP_sf32: |
| case OP_sf64: |
| // consume two stack entries |
| stkdepth = adjustValueStack(stkdepth, -2); |
| break; |
| |
| case OP_callinterface: |
| case OP_callsuperid: |
| case OP_deletepropertylate: |
| case OP_setpropertylate: |
| assert false : "internal only instruction!"; |
| break; |
| default: |
| assert false : "unknown instruction!"; |
| break; |
| } |
| this.instructionIndex++; |
| } |
| |
| public void visitEnd(IBasicBlock b) |
| { |
| for (IBasicBlock s : b.getSuccessors()) |
| { |
| if (!stkin.containsKey(s)) |
| { |
| stkin.put(s, stkdepth); |
| scpin.put(s, scpdepth); |
| } |
| } |
| } |
| |
| private int adjustValueStack(int stkdepth, int incr) |
| { |
| stkdepth += incr; |
| |
| if (stkdepth < 0) |
| this.diagnosticsVisitor.operandStackUnderflow(this.mbi, this.cfg, this.currentBlock, instructionIndex); |
| |
| if (stkdepth > this.max_stack) |
| this.max_stack = stkdepth; |
| return stkdepth; |
| } |
| |
| private int adjustScopeStack(int scpdepth, int incr) |
| { |
| scpdepth += incr; |
| |
| if (scpdepth < 0) |
| this.diagnosticsVisitor.scopeStackUnderflow(this.mbi, this.cfg, this.currentBlock, instructionIndex); |
| |
| if (scpdepth > (this.max_scope - this.initial_scope)) |
| { |
| this.max_scope = scpdepth + this.initial_scope; |
| } |
| return scpdepth; |
| } |
| |
| private void adjustMaxLocal(int idx) |
| { |
| if (max_local <= idx) |
| max_local = idx + 1; |
| } |
| |
| /** |
| * Examine a Name and compute the number of value stack elements it will |
| * need in its evaluation. |
| * |
| * @param operand - the runtime name. May be null if the operation can |
| * function without a name operand. |
| * @return the number of value stack elements evaluating this Name requires. |
| */ |
| private int runtimeNameAllowance(Object operand) |
| { |
| return operand instanceof Name ? |
| -((Name)operand).runtimeNameAllowance() : |
| 0; |
| } |
| |
| public boolean hasNewclassInstruction() |
| { |
| return this.hasNewclass; |
| } |
| } |
