| /* |
| * Copyright (c) 1994, 2003, 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 sun.tools.asm; |
| |
| import sun.tools.java.*; |
| import java.util.Enumeration; |
| import java.io.IOException; |
| import java.io.DataOutputStream; |
| import java.io.PrintStream; |
| import java.util.Vector; |
| // JCOV |
| import sun.tools.javac.*; |
| import java.io.File; |
| import java.io.BufferedInputStream; |
| import java.io.DataInputStream; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.lang.String; |
| // end JCOV |
| |
| /** |
| * This class is used to assemble the bytecode instructions for a method. |
| * |
| * WARNING: The contents of this source file are not part of any |
| * supported API. Code that depends on them does so at its own risk: |
| * they are subject to change or removal without notice. |
| * |
| * @author Arthur van Hoff |
| */ |
| public final |
| class Assembler implements Constants { |
| static final int NOTREACHED = 0; |
| static final int REACHED = 1; |
| static final int NEEDED = 2; |
| |
| Label first = new Label(); |
| Instruction last = first; |
| int maxdepth; |
| int maxvar; |
| int maxpc; |
| |
| /** |
| * Add an instruction |
| */ |
| public void add(Instruction inst) { |
| if (inst != null) { |
| last.next = inst; |
| last = inst; |
| } |
| } |
| public void add(long where, int opc) { |
| add(new Instruction(where, opc, null)); |
| } |
| public void add(long where, int opc, Object obj) { |
| add(new Instruction(where, opc, obj)); |
| } |
| // JCOV |
| public void add(long where, int opc, Object obj, boolean flagCondInverted) { |
| add(new Instruction(where, opc, obj, flagCondInverted)); |
| } |
| |
| public void add(boolean flagNoCovered, long where, int opc, Object obj) { |
| add(new Instruction(flagNoCovered, where, opc, obj)); |
| } |
| |
| public void add(long where, int opc, boolean flagNoCovered) { |
| add(new Instruction(where, opc, flagNoCovered)); |
| } |
| |
| static Vector SourceClassList = new Vector(); |
| |
| static Vector TmpCovTable = new Vector(); |
| |
| static int[] JcovClassCountArray = new int[CT_LAST_KIND + 1]; |
| |
| static String JcovMagicLine = "JCOV-DATA-FILE-VERSION: 2.0"; |
| static String JcovClassLine = "CLASS: "; |
| static String JcovSrcfileLine = "SRCFILE: "; |
| static String JcovTimestampLine = "TIMESTAMP: "; |
| static String JcovDataLine = "DATA: "; |
| static String JcovHeadingLine = "#kind\tcount"; |
| |
| static int[] arrayModifiers = |
| {M_PUBLIC, M_PRIVATE, M_PROTECTED, M_ABSTRACT, M_FINAL, M_INTERFACE}; |
| static int[] arrayModifiersOpc = |
| {PUBLIC, PRIVATE, PROTECTED, ABSTRACT, FINAL, INTERFACE}; |
| //end JCOV |
| |
| /** |
| * Optimize instructions and mark those that can be reached |
| */ |
| void optimize(Environment env, Label lbl) { |
| lbl.pc = REACHED; |
| |
| for (Instruction inst = lbl.next ; inst != null ; inst = inst.next) { |
| switch (inst.pc) { |
| case NOTREACHED: |
| inst.optimize(env); |
| inst.pc = REACHED; |
| break; |
| case REACHED: |
| return; |
| case NEEDED: |
| break; |
| } |
| |
| switch (inst.opc) { |
| case opc_label: |
| case opc_dead: |
| if (inst.pc == REACHED) { |
| inst.pc = NOTREACHED; |
| } |
| break; |
| |
| case opc_ifeq: |
| case opc_ifne: |
| case opc_ifgt: |
| case opc_ifge: |
| case opc_iflt: |
| case opc_ifle: |
| case opc_if_icmpeq: |
| case opc_if_icmpne: |
| case opc_if_icmpgt: |
| case opc_if_icmpge: |
| case opc_if_icmplt: |
| case opc_if_icmple: |
| case opc_if_acmpeq: |
| case opc_if_acmpne: |
| case opc_ifnull: |
| case opc_ifnonnull: |
| optimize(env, (Label)inst.value); |
| break; |
| |
| case opc_goto: |
| optimize(env, (Label)inst.value); |
| return; |
| |
| case opc_jsr: |
| optimize(env, (Label)inst.value); |
| break; |
| |
| case opc_ret: |
| case opc_return: |
| case opc_ireturn: |
| case opc_lreturn: |
| case opc_freturn: |
| case opc_dreturn: |
| case opc_areturn: |
| case opc_athrow: |
| return; |
| |
| case opc_tableswitch: |
| case opc_lookupswitch: { |
| SwitchData sw = (SwitchData)inst.value; |
| optimize(env, sw.defaultLabel); |
| for (Enumeration e = sw.tab.elements() ; e.hasMoreElements();) { |
| optimize(env, (Label)e.nextElement()); |
| } |
| return; |
| } |
| |
| case opc_try: { |
| TryData td = (TryData)inst.value; |
| td.getEndLabel().pc = NEEDED; |
| for (Enumeration e = td.catches.elements() ; e.hasMoreElements();) { |
| CatchData cd = (CatchData)e.nextElement(); |
| optimize(env, cd.getLabel()); |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Eliminate instructions that are not reached |
| */ |
| boolean eliminate() { |
| boolean change = false; |
| Instruction prev = first; |
| |
| for (Instruction inst = first.next ; inst != null ; inst = inst.next) { |
| if (inst.pc != NOTREACHED) { |
| prev.next = inst; |
| prev = inst; |
| inst.pc = NOTREACHED; |
| } else { |
| change = true; |
| } |
| } |
| first.pc = NOTREACHED; |
| prev.next = null; |
| return change; |
| } |
| |
| /** |
| * Optimize the byte codes |
| */ |
| public void optimize(Environment env) { |
| //listing(System.out); |
| do { |
| // Figure out which instructions are reached |
| optimize(env, first); |
| |
| // Eliminate instructions that are not reached |
| } while (eliminate() && env.opt()); |
| } |
| |
| /** |
| * Collect all constants into the constant table |
| */ |
| public void collect(Environment env, MemberDefinition field, ConstantPool tab) { |
| // Collect constants for arguments only |
| // if a local variable table is generated |
| if ((field != null) && env.debug_vars()) { |
| if (field.getArguments() != null) { |
| for (Enumeration e = field.getArguments().elements() ; e.hasMoreElements() ;) { |
| MemberDefinition f = (MemberDefinition)e.nextElement(); |
| tab.put(f.getName().toString()); |
| tab.put(f.getType().getTypeSignature()); |
| } |
| } |
| } |
| |
| // Collect constants from the instructions |
| for (Instruction inst = first ; inst != null ; inst = inst.next) { |
| inst.collect(tab); |
| } |
| } |
| |
| /** |
| * Determine stack size, count local variables |
| */ |
| void balance(Label lbl, int depth) { |
| for (Instruction inst = lbl ; inst != null ; inst = inst.next) { |
| //Environment.debugOutput(inst.toString() + ": " + depth + " => " + |
| // (depth + inst.balance())); |
| depth += inst.balance(); |
| if (depth < 0) { |
| throw new CompilerError("stack under flow: " + inst.toString() + " = " + depth); |
| } |
| if (depth > maxdepth) { |
| maxdepth = depth; |
| } |
| switch (inst.opc) { |
| case opc_label: |
| lbl = (Label)inst; |
| if (inst.pc == REACHED) { |
| if (lbl.depth != depth) { |
| throw new CompilerError("stack depth error " + |
| depth + "/" + lbl.depth + |
| ": " + inst.toString()); |
| } |
| return; |
| } |
| lbl.pc = REACHED; |
| lbl.depth = depth; |
| break; |
| |
| case opc_ifeq: |
| case opc_ifne: |
| case opc_ifgt: |
| case opc_ifge: |
| case opc_iflt: |
| case opc_ifle: |
| case opc_if_icmpeq: |
| case opc_if_icmpne: |
| case opc_if_icmpgt: |
| case opc_if_icmpge: |
| case opc_if_icmplt: |
| case opc_if_icmple: |
| case opc_if_acmpeq: |
| case opc_if_acmpne: |
| case opc_ifnull: |
| case opc_ifnonnull: |
| balance((Label)inst.value, depth); |
| break; |
| |
| case opc_goto: |
| balance((Label)inst.value, depth); |
| return; |
| |
| case opc_jsr: |
| balance((Label)inst.value, depth + 1); |
| break; |
| |
| case opc_ret: |
| case opc_return: |
| case opc_ireturn: |
| case opc_lreturn: |
| case opc_freturn: |
| case opc_dreturn: |
| case opc_areturn: |
| case opc_athrow: |
| return; |
| |
| case opc_iload: |
| case opc_fload: |
| case opc_aload: |
| case opc_istore: |
| case opc_fstore: |
| case opc_astore: { |
| int v = ((inst.value instanceof Number) |
| ? ((Number)inst.value).intValue() |
| : ((LocalVariable)inst.value).slot) + 1; |
| if (v > maxvar) |
| maxvar = v; |
| break; |
| } |
| |
| case opc_lload: |
| case opc_dload: |
| case opc_lstore: |
| case opc_dstore: { |
| int v = ((inst.value instanceof Number) |
| ? ((Number)inst.value).intValue() |
| : ((LocalVariable)inst.value).slot) + 2; |
| if (v > maxvar) |
| maxvar = v; |
| break; |
| } |
| |
| case opc_iinc: { |
| int v = ((int[])inst.value)[0] + 1; |
| if (v > maxvar) |
| maxvar = v + 1; |
| break; |
| } |
| |
| case opc_tableswitch: |
| case opc_lookupswitch: { |
| SwitchData sw = (SwitchData)inst.value; |
| balance(sw.defaultLabel, depth); |
| for (Enumeration e = sw.tab.elements() ; e.hasMoreElements();) { |
| balance((Label)e.nextElement(), depth); |
| } |
| return; |
| } |
| |
| case opc_try: { |
| TryData td = (TryData)inst.value; |
| for (Enumeration e = td.catches.elements() ; e.hasMoreElements();) { |
| CatchData cd = (CatchData)e.nextElement(); |
| balance(cd.getLabel(), depth + 1); |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Generate code |
| */ |
| public void write(Environment env, DataOutputStream out, |
| MemberDefinition field, ConstantPool tab) |
| throws IOException { |
| //listing(System.out); |
| |
| if ((field != null) && field.getArguments() != null) { |
| int sum = 0; |
| Vector v = field.getArguments(); |
| for (Enumeration e = v.elements(); e.hasMoreElements(); ) { |
| MemberDefinition f = ((MemberDefinition)e.nextElement()); |
| sum += f.getType().stackSize(); |
| } |
| maxvar = sum; |
| } |
| |
| // Make sure the stack balances. Also calculate maxvar and maxstack |
| try { |
| balance(first, 0); |
| } catch (CompilerError e) { |
| System.out.println("ERROR: " + e); |
| listing(System.out); |
| throw e; |
| } |
| |
| // Assign PCs |
| int pc = 0, nexceptions = 0; |
| for (Instruction inst = first ; inst != null ; inst = inst.next) { |
| inst.pc = pc; |
| int sz = inst.size(tab); |
| if (pc<65536 && (pc+sz)>=65536) { |
| env.error(inst.where, "warn.method.too.long"); |
| } |
| pc += sz; |
| |
| if (inst.opc == opc_try) { |
| nexceptions += ((TryData)inst.value).catches.size(); |
| } |
| } |
| |
| // Write header |
| out.writeShort(maxdepth); |
| out.writeShort(maxvar); |
| out.writeInt(maxpc = pc); |
| |
| // Generate code |
| for (Instruction inst = first.next ; inst != null ; inst = inst.next) { |
| inst.write(out, tab); |
| } |
| |
| // write exceptions |
| out.writeShort(nexceptions); |
| if (nexceptions > 0) { |
| //listing(System.out); |
| writeExceptions(env, out, tab, first, last); |
| } |
| } |
| |
| /** |
| * Write the exceptions table |
| */ |
| void writeExceptions(Environment env, DataOutputStream out, ConstantPool tab, Instruction first, Instruction last) throws IOException { |
| for (Instruction inst = first ; inst != last.next ; inst = inst.next) { |
| if (inst.opc == opc_try) { |
| TryData td = (TryData)inst.value; |
| writeExceptions(env, out, tab, inst.next, td.getEndLabel()); |
| for (Enumeration e = td.catches.elements() ; e.hasMoreElements();) { |
| CatchData cd = (CatchData)e.nextElement(); |
| //System.out.println("EXCEPTION: " + env.getSource() + ", pc=" + inst.pc + ", end=" + td.getEndLabel().pc + ", hdl=" + cd.getLabel().pc + ", tp=" + cd.getType()); |
| out.writeShort(inst.pc); |
| out.writeShort(td.getEndLabel().pc); |
| out.writeShort(cd.getLabel().pc); |
| if (cd.getType() != null) { |
| out.writeShort(tab.index(cd.getType())); |
| } else { |
| out.writeShort(0); |
| } |
| } |
| inst = td.getEndLabel(); |
| } |
| } |
| } |
| |
| //JCOV |
| /** |
| * Write the coverage table |
| */ |
| public void writeCoverageTable(Environment env, ClassDefinition c, DataOutputStream out, ConstantPool tab, long whereField) throws IOException { |
| Vector TableLot = new Vector(); /* Coverage table */ |
| boolean begseg = false; |
| boolean begmeth = false; |
| long whereClass = ((SourceClass)c).getWhere(); |
| Vector whereTry = new Vector(); |
| int numberTry = 0; |
| int count = 0; |
| |
| for (Instruction inst = first ; inst != null ; inst = inst.next) { |
| long n = (inst.where >> WHEREOFFSETBITS); |
| if (n > 0 && inst.opc != opc_label) { |
| if (!begmeth) { |
| if ( whereClass == inst.where) |
| TableLot.addElement(new Cover(CT_FIKT_METHOD, whereField, inst.pc)); |
| else |
| TableLot.addElement(new Cover(CT_METHOD, whereField, inst.pc)); |
| count++; |
| begmeth = true; |
| } |
| if (!begseg && !inst.flagNoCovered ) { |
| boolean findTry = false; |
| for (Enumeration e = whereTry.elements(); e.hasMoreElements();) { |
| if ( ((Long)(e.nextElement())).longValue() == inst.where) { |
| findTry = true; |
| break; |
| } |
| } |
| if (!findTry) { |
| TableLot.addElement(new Cover(CT_BLOCK, inst.where, inst.pc)); |
| count++; |
| begseg = true; |
| } |
| } |
| } |
| switch (inst.opc) { |
| case opc_label: |
| begseg = false; |
| break; |
| case opc_ifeq: |
| case opc_ifne: |
| case opc_ifnull: |
| case opc_ifnonnull: |
| case opc_ifgt: |
| case opc_ifge: |
| case opc_iflt: |
| case opc_ifle: |
| case opc_if_icmpeq: |
| case opc_if_icmpne: |
| case opc_if_icmpgt: |
| case opc_if_icmpge: |
| case opc_if_icmplt: |
| case opc_if_icmple: |
| case opc_if_acmpeq: |
| case opc_if_acmpne: { |
| if ( inst.flagCondInverted ) { |
| TableLot.addElement(new Cover(CT_BRANCH_TRUE, inst.where, inst.pc)); |
| TableLot.addElement(new Cover(CT_BRANCH_FALSE, inst.where, inst.pc)); |
| } else { |
| TableLot.addElement(new Cover(CT_BRANCH_FALSE, inst.where, inst.pc)); |
| TableLot.addElement(new Cover(CT_BRANCH_TRUE, inst.where, inst.pc)); |
| } |
| count += 2; |
| begseg = false; |
| break; |
| } |
| |
| case opc_goto: { |
| begseg = false; |
| break; |
| } |
| |
| case opc_ret: |
| case opc_return: |
| case opc_ireturn: |
| case opc_lreturn: |
| case opc_freturn: |
| case opc_dreturn: |
| case opc_areturn: |
| case opc_athrow: { |
| break; |
| } |
| |
| case opc_try: { |
| whereTry.addElement(new Long(inst.where)); |
| begseg = false; |
| break; |
| } |
| |
| case opc_tableswitch: { |
| SwitchData sw = (SwitchData)inst.value; |
| for (int i = sw.minValue; i <= sw.maxValue; i++) { |
| TableLot.addElement(new Cover(CT_CASE, sw.whereCase(new Integer(i)), inst.pc)); |
| count++; |
| } |
| if (!sw.getDefault()) { |
| TableLot.addElement(new Cover(CT_SWITH_WO_DEF, inst.where, inst.pc)); |
| count++; |
| } else { |
| TableLot.addElement(new Cover(CT_CASE, sw.whereCase("default"), inst.pc)); |
| count++; |
| } |
| begseg = false; |
| break; |
| } |
| case opc_lookupswitch: { |
| SwitchData sw = (SwitchData)inst.value; |
| for (Enumeration e = sw.sortedKeys(); e.hasMoreElements() ; ) { |
| Integer v = (Integer)e.nextElement(); |
| TableLot.addElement(new Cover(CT_CASE, sw.whereCase(v), inst.pc)); |
| count++; |
| } |
| if (!sw.getDefault()) { |
| TableLot.addElement(new Cover(CT_SWITH_WO_DEF, inst.where, inst.pc)); |
| count++; |
| } else { |
| TableLot.addElement(new Cover(CT_CASE, sw.whereCase("default"), inst.pc)); |
| count++; |
| } |
| begseg = false; |
| break; |
| } |
| } |
| } |
| Cover Lot; |
| long ln, pos; |
| |
| out.writeShort(count); |
| for (int i = 0; i < count; i++) { |
| Lot = (Cover)TableLot.elementAt(i); |
| ln = (Lot.Addr >> WHEREOFFSETBITS); |
| pos = (Lot.Addr << (64 - WHEREOFFSETBITS)) >> (64 - WHEREOFFSETBITS); |
| out.writeShort(Lot.NumCommand); |
| out.writeShort(Lot.Type); |
| out.writeInt((int)ln); |
| out.writeInt((int)pos); |
| |
| if ( !(Lot.Type == CT_CASE && Lot.Addr == 0) ) { |
| JcovClassCountArray[Lot.Type]++; |
| } |
| } |
| |
| } |
| |
| /* |
| * Increase count of methods for native methods |
| */ |
| |
| public void addNativeToJcovTab(Environment env, ClassDefinition c) { |
| JcovClassCountArray[CT_METHOD]++; |
| } |
| |
| /* |
| * Create class jcov element |
| */ |
| |
| private String createClassJcovElement(Environment env, ClassDefinition c) { |
| String SourceClass = (Type.mangleInnerType((c.getClassDeclaration()).getName())).toString(); |
| String ConvSourceClass; |
| String classJcovLine; |
| |
| SourceClassList.addElement(SourceClass); |
| ConvSourceClass = SourceClass.replace('.', '/'); |
| classJcovLine = JcovClassLine + ConvSourceClass; |
| |
| classJcovLine = classJcovLine + " ["; |
| String blank = ""; |
| |
| for (int i = 0; i < arrayModifiers.length; i++ ) { |
| if ((c.getModifiers() & arrayModifiers[i]) != 0) { |
| classJcovLine = classJcovLine + blank + opNames[arrayModifiersOpc[i]]; |
| blank = " "; |
| } |
| } |
| classJcovLine = classJcovLine + "]"; |
| |
| return classJcovLine; |
| } |
| |
| /* |
| * generate coverage data |
| */ |
| |
| public void GenVecJCov(Environment env, ClassDefinition c, long Time) { |
| String SourceFile = ((SourceClass)c).getAbsoluteName(); |
| |
| TmpCovTable.addElement(createClassJcovElement(env, c)); |
| TmpCovTable.addElement(JcovSrcfileLine + SourceFile); |
| TmpCovTable.addElement(JcovTimestampLine + Time); |
| TmpCovTable.addElement(JcovDataLine + "A"); // data format |
| TmpCovTable.addElement(JcovHeadingLine); |
| |
| for (int i = CT_FIRST_KIND; i <= CT_LAST_KIND; i++) { |
| if (JcovClassCountArray[i] != 0) { |
| TmpCovTable.addElement(new String(i + "\t" + JcovClassCountArray[i])); |
| JcovClassCountArray[i] = 0; |
| } |
| } |
| } |
| |
| |
| /* |
| * generate file of coverage data |
| */ |
| |
| public void GenJCov(Environment env) { |
| |
| try { |
| File outFile = env.getcovFile(); |
| if( outFile.exists()) { |
| DataInputStream JCovd = new DataInputStream( |
| new BufferedInputStream( |
| new FileInputStream(outFile))); |
| String CurrLine = null; |
| boolean first = true; |
| String Class; |
| |
| CurrLine = JCovd.readLine(); |
| if ((CurrLine != null) && CurrLine.startsWith(JcovMagicLine)) { |
| // this is a good Jcov file |
| |
| while((CurrLine = JCovd.readLine()) != null ) { |
| if ( CurrLine.startsWith(JcovClassLine) ) { |
| first = true; |
| for(Enumeration e = SourceClassList.elements(); e.hasMoreElements();) { |
| String clsName = CurrLine.substring(JcovClassLine.length()); |
| int idx = clsName.indexOf(' '); |
| |
| if (idx != -1) { |
| clsName = clsName.substring(0, idx); |
| } |
| Class = (String)e.nextElement(); |
| if ( Class.compareTo(clsName) == 0) { |
| first = false; |
| break; |
| } |
| } |
| } |
| if (first) // re-write old class |
| TmpCovTable.addElement(CurrLine); |
| } |
| } |
| JCovd.close(); |
| } |
| PrintStream CovFile = new PrintStream(new DataOutputStream(new FileOutputStream(outFile))); |
| CovFile.println(JcovMagicLine); |
| for(Enumeration e = TmpCovTable.elements(); e.hasMoreElements();) { |
| CovFile.println(e.nextElement()); |
| } |
| CovFile.close(); |
| } |
| catch (FileNotFoundException e) { |
| System.out.println("ERROR: " + e); |
| } |
| catch (IOException e) { |
| System.out.println("ERROR: " + e); |
| } |
| } |
| // end JCOV |
| |
| |
| /** |
| * Write the linenumber table |
| */ |
| public void writeLineNumberTable(Environment env, DataOutputStream out, ConstantPool tab) throws IOException { |
| long ln = -1; |
| int count = 0; |
| |
| for (Instruction inst = first ; inst != null ; inst = inst.next) { |
| long n = (inst.where >> WHEREOFFSETBITS); |
| if ((n > 0) && (ln != n)) { |
| ln = n; |
| count++; |
| } |
| } |
| |
| ln = -1; |
| out.writeShort(count); |
| for (Instruction inst = first ; inst != null ; inst = inst.next) { |
| long n = (inst.where >> WHEREOFFSETBITS); |
| if ((n > 0) && (ln != n)) { |
| ln = n; |
| out.writeShort(inst.pc); |
| out.writeShort((int)ln); |
| //System.out.println("pc = " + inst.pc + ", ln = " + ln); |
| } |
| } |
| } |
| |
| /** |
| * Figure out when registers contain a legal value. This is done |
| * using a simple data flow algorithm. This information is later used |
| * to generate the local variable table. |
| */ |
| void flowFields(Environment env, Label lbl, MemberDefinition locals[]) { |
| if (lbl.locals != null) { |
| // Been here before. Erase any conflicts. |
| MemberDefinition f[] = lbl.locals; |
| for (int i = 0 ; i < maxvar ; i++) { |
| if (f[i] != locals[i]) { |
| f[i] = null; |
| } |
| } |
| return; |
| } |
| |
| // Remember the set of active registers at this point |
| lbl.locals = new MemberDefinition[maxvar]; |
| System.arraycopy(locals, 0, lbl.locals, 0, maxvar); |
| |
| MemberDefinition newlocals[] = new MemberDefinition[maxvar]; |
| System.arraycopy(locals, 0, newlocals, 0, maxvar); |
| locals = newlocals; |
| |
| for (Instruction inst = lbl.next ; inst != null ; inst = inst.next) { |
| switch (inst.opc) { |
| case opc_istore: case opc_istore_0: case opc_istore_1: |
| case opc_istore_2: case opc_istore_3: |
| case opc_fstore: case opc_fstore_0: case opc_fstore_1: |
| case opc_fstore_2: case opc_fstore_3: |
| case opc_astore: case opc_astore_0: case opc_astore_1: |
| case opc_astore_2: case opc_astore_3: |
| case opc_lstore: case opc_lstore_0: case opc_lstore_1: |
| case opc_lstore_2: case opc_lstore_3: |
| case opc_dstore: case opc_dstore_0: case opc_dstore_1: |
| case opc_dstore_2: case opc_dstore_3: |
| if (inst.value instanceof LocalVariable) { |
| LocalVariable v = (LocalVariable)inst.value; |
| locals[v.slot] = v.field; |
| } |
| break; |
| |
| case opc_label: |
| flowFields(env, (Label)inst, locals); |
| return; |
| |
| case opc_ifeq: case opc_ifne: case opc_ifgt: |
| case opc_ifge: case opc_iflt: case opc_ifle: |
| case opc_if_icmpeq: case opc_if_icmpne: case opc_if_icmpgt: |
| case opc_if_icmpge: case opc_if_icmplt: case opc_if_icmple: |
| case opc_if_acmpeq: case opc_if_acmpne: |
| case opc_ifnull: case opc_ifnonnull: |
| case opc_jsr: |
| flowFields(env, (Label)inst.value, locals); |
| break; |
| |
| case opc_goto: |
| flowFields(env, (Label)inst.value, locals); |
| return; |
| |
| case opc_return: case opc_ireturn: case opc_lreturn: |
| case opc_freturn: case opc_dreturn: case opc_areturn: |
| case opc_athrow: case opc_ret: |
| return; |
| |
| case opc_tableswitch: |
| case opc_lookupswitch: { |
| SwitchData sw = (SwitchData)inst.value; |
| flowFields(env, sw.defaultLabel, locals); |
| for (Enumeration e = sw.tab.elements() ; e.hasMoreElements();) { |
| flowFields(env, (Label)e.nextElement(), locals); |
| } |
| return; |
| } |
| |
| case opc_try: { |
| Vector catches = ((TryData)inst.value).catches; |
| for (Enumeration e = catches.elements(); e.hasMoreElements();) { |
| CatchData cd = (CatchData)e.nextElement(); |
| flowFields(env, cd.getLabel(), locals); |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Write the local variable table. The necessary constants have already been |
| * added to the constant table by the collect() method. The flowFields method |
| * is used to determine which variables are alive at each pc. |
| */ |
| public void writeLocalVariableTable(Environment env, MemberDefinition field, DataOutputStream out, ConstantPool tab) throws IOException { |
| MemberDefinition locals[] = new MemberDefinition[maxvar]; |
| int i = 0; |
| |
| // Initialize arguments |
| if ((field != null) && (field.getArguments() != null)) { |
| int reg = 0; |
| Vector v = field.getArguments(); |
| for (Enumeration e = v.elements(); e.hasMoreElements(); ) { |
| MemberDefinition f = ((MemberDefinition)e.nextElement()); |
| locals[reg] = f; |
| reg += f.getType().stackSize(); |
| } |
| } |
| |
| flowFields(env, first, locals); |
| LocalVariableTable lvtab = new LocalVariableTable(); |
| |
| // Initialize arguments again |
| for (i = 0; i < maxvar; i++) |
| locals[i] = null; |
| if ((field != null) && (field.getArguments() != null)) { |
| int reg = 0; |
| Vector v = field.getArguments(); |
| for (Enumeration e = v.elements(); e.hasMoreElements(); ) { |
| MemberDefinition f = ((MemberDefinition)e.nextElement()); |
| locals[reg] = f; |
| lvtab.define(f, reg, 0, maxpc); |
| reg += f.getType().stackSize(); |
| } |
| } |
| |
| int pcs[] = new int[maxvar]; |
| |
| for (Instruction inst = first ; inst != null ; inst = inst.next) { |
| switch (inst.opc) { |
| case opc_istore: case opc_istore_0: case opc_istore_1: |
| case opc_istore_2: case opc_istore_3: case opc_fstore: |
| case opc_fstore_0: case opc_fstore_1: case opc_fstore_2: |
| case opc_fstore_3: |
| case opc_astore: case opc_astore_0: case opc_astore_1: |
| case opc_astore_2: case opc_astore_3: |
| case opc_lstore: case opc_lstore_0: case opc_lstore_1: |
| case opc_lstore_2: case opc_lstore_3: |
| case opc_dstore: case opc_dstore_0: case opc_dstore_1: |
| case opc_dstore_2: case opc_dstore_3: |
| if (inst.value instanceof LocalVariable) { |
| LocalVariable v = (LocalVariable)inst.value; |
| int pc = (inst.next != null) ? inst.next.pc : inst.pc; |
| if (locals[v.slot] != null) { |
| lvtab.define(locals[v.slot], v.slot, pcs[v.slot], pc); |
| } |
| pcs[v.slot] = pc; |
| locals[v.slot] = v.field; |
| } |
| break; |
| |
| case opc_label: { |
| // flush previous labels |
| for (i = 0 ; i < maxvar ; i++) { |
| if (locals[i] != null) { |
| lvtab.define(locals[i], i, pcs[i], inst.pc); |
| } |
| } |
| // init new labels |
| int pc = inst.pc; |
| MemberDefinition[] labelLocals = ((Label)inst).locals; |
| if (labelLocals == null) { // unreachable code?? |
| for (i = 0; i < maxvar; i++) |
| locals[i] = null; |
| } else { |
| System.arraycopy(labelLocals, 0, locals, 0, maxvar); |
| } |
| for (i = 0 ; i < maxvar ; i++) { |
| pcs[i] = pc; |
| } |
| break; |
| } |
| } |
| } |
| |
| // flush remaining labels |
| for (i = 0 ; i < maxvar ; i++) { |
| if (locals[i] != null) { |
| lvtab.define(locals[i], i, pcs[i], maxpc); |
| } |
| } |
| |
| // write the local variable table |
| lvtab.write(env, out, tab); |
| } |
| |
| /** |
| * Return true if empty |
| */ |
| public boolean empty() { |
| return first == last; |
| } |
| |
| /** |
| * Print the byte codes |
| */ |
| public void listing(PrintStream out) { |
| out.println("-- listing --"); |
| for (Instruction inst = first ; inst != null ; inst = inst.next) { |
| out.println(inst.toString()); |
| } |
| } |
| } |
