/*

 * 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.

 *

 * 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.

 */

/*

 * An extension of BinaryCode that allows code to be printed.

 * Includes printing of disassembled byte codes, exception info,

 * local variable and line number info.

 *

 */

package ilib;

import java.io.ByteArrayInputStream;

import java.io.CharArrayWriter;

import java.io.DataInputStream;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.PrintStream;

import java.util.Map;

import java.util.HashMap;

class InjectBytecodes implements RuntimeConstants {

    private final ClassReaderWriter c;

    private final PrintStream output;

    private final int length;

    private final int[] map;

    private final byte[] widening;

    private final Injector[] before = new Injector[256];

    private final Injector[] after  = new Injector[256];

    private final String className;

    private final String methodName;

    private final Map<Integer,byte[]> snippets = new HashMap<>();

    private int pos;

    private int newPos;

    private class Span {

        final int delta;

        final int target;

        final int newDelta;

        final int newTarget;

        Span(int delta) {

            this.delta = delta;

            this.target = pos + delta;

            this.newTarget = map[target];

            this.newDelta = newTarget - newPos;

        }

    }

    /**

     * Constructor

     */

    InjectBytecodes(ClassReaderWriter c, int length,

                    String className, String methodName) {

        this.c = c;

        this.output = System.out;

        this.length = length;

        this.map = new int[length + 1];

        this.widening = new byte[length + 1];

        this.className = className;

        this.methodName = methodName;

        c.markLocalPositionStart();

        for (int i = 0; i <= length; ++i) {

            map[i] = i;

        }

    }

    public void inject(int at, byte[] newCode) {

        snippets.put(new Integer(at), newCode);

        trace("external ");

        inject(at, newCode.length);

    }

    private void inject(int at, int len) {

        if (Inject.verbose) {

            traceln("Injecting " + len + " at " + at);

        }

        for (int i = at; i <= length; ++i) {

            map[i] += len;

        }

    }

    private void widen(int at, int len) {

        int delta = len - widening[at];

        if (Inject.verbose) {

            traceln();

            traceln("Widening to " + len + " at " + at);

        }

        inject(c.localPosition(), delta);  // inject at end of instruction

        widening[at] = (byte)len;          // mark at beginning of instruction

    }

    public void injectBefore(int code, Injector inj) {

        before[code] = inj;

    }

    public void injectAfter(int code, Injector inj) {

        after[code] = inj;

    }

    private void trace(String str) {

        if (Inject.verbose) {

            output.print(str);

        }

    }

    private void traceln(String str) {

        if (Inject.verbose) {

            output.println(str);

        }

    }

    private void traceln() {

        if (Inject.verbose) {

            output.println();

        }

    }

    private void trace(int i) {

        if (Inject.verbose) {

            output.print(i);

        }

    }

    /**

     * Print an integer so that it takes 'length' characters in

     * the output.  Temporary until formatting code is stable.

     */

    private void traceFixedWidthInt(int x, int length) {

        if (Inject.verbose) {

            CharArrayWriter baStream = new CharArrayWriter();

            PrintWriter pStream = new PrintWriter(baStream);

            pStream.print(x);

            String str = baStream.toString();

            for (int cnt = length - str.length(); cnt > 0; --cnt)

                trace(" ");

            trace(str);

        }

    }

    void adjustOffsets() throws IOException {

        if (Inject.verbose) {

            traceln();

            traceln("Method " + methodName);

            traceln();

        }

        c.rewind();

        while (c.localPosition() < length) {

            insertAtInstruction();

        }

        trace("Searching for adjustments...");

        c.rewind();

        while (c.localPosition() < length) {

            if (!adjustInstruction()) {

                c.rewind();

                traceln();

                traceln("Restarting adjustments after change...");

            }

        }

        // write the new bytecodes

        traceln();

        traceln();

        trace("Writing new code...");

        c.rewind();

        while (c.localPosition() < length) {

            writeInstruction();

        }

        if (!snippets.isEmpty()) {

            throw new Error("not all snippets written");

        }

    }

    /**

     * Walk one instruction inserting instrumentation at specified instructions

     */

    private void insertAtInstruction() throws IOException {

        pos = c.localPosition();

        int opcode = c.readU1();

        if (opcode == opc_wide) {

            // no support for instrumenting wide instructions

            int wopcode = c.readU1();

            int lvIndex = c.readU2();

            switch (wopcode) {

            case opc_aload: case opc_astore:

            case opc_fload: case opc_fstore:

            case opc_iload: case opc_istore:

            case opc_lload: case opc_lstore:

            case opc_dload: case opc_dstore:

            case opc_ret:

                break;

            case opc_iinc:

                c.readS2();

                break;

            default:

                throw new Error("Invalid wide opcode: " + wopcode);

            }

        } else {

            Injector inj;

            inj = before[opcode];

            if (inj != null) {

                inject(pos, inj.bytecodes(className, methodName, pos));

            }

            switch (opcode) {

            case opc_tableswitch:{

                int header = (pos+1+3) & (~3);        // 4byte boundry

                c.skip(header - (pos+1));             // skip old padding

                c.readU4();

                int low = c.readU4();

                int high = c.readU4();

                c.skip((high+1-low) * 4);

                break;

            }

            case opc_lookupswitch:{

                int header = (pos+1+3) & (~3);        // 4byte boundry

                c.skip(header - (pos+1));             // skip padding

                c.readU4();

                int npairs = c.readU4();

                c.skip(npairs * 8);

                break;

            }

            default: {

                int instrLen = opcLengths[opcode];

                c.skip(instrLen-1);

            }

            }

            inj = after[opcode];

            if (inj != null) {

                pos = c.localPosition();

                inject(pos, inj.bytecodes(className, methodName, pos));

            }

        }

    }

    /**

     * Walk one instruction adjusting for insertions

     */

    private boolean adjustInstruction() throws IOException {

        pos = c.localPosition();

        newPos = map[pos];

        int opcode = c.readU1();

        if (Inject.verbose) {

            traceln();

            traceFixedWidthInt(pos, 4);

            traceFixedWidthInt(newPos, 4);

            trace(" ");

        }

        if (opcode == opc_wide) {

            int wopcode = c.readU1();

            int lvIndex = c.readU2();

            if (Inject.verbose) {

                trace(opcNames[wopcode] + "_w ");

            }

            switch (wopcode) {

            case opc_aload: case opc_astore:

            case opc_fload: case opc_fstore:

            case opc_iload: case opc_istore:

            case opc_lload: case opc_lstore:

            case opc_dload: case opc_dstore:

            case opc_ret:

                trace(lvIndex);

                break;

            case opc_iinc:

                int constVal = c.readS2();

                if (Inject.verbose) {

                    trace(lvIndex + " " + constVal);

                }

                break;

            default:

                throw new Error("Invalid wide opcode: " + wopcode);

            }

        } else {

            if (Inject.verbose) {

                trace(opcNames[opcode]);

            }

            switch (opcode) {

            case opc_tableswitch:{

                int widened = widening[pos];

                int header = (pos+1+3) & (~3);        // 4byte boundry

                int newHeader = (newPos+1+3) & (~3);  // 4byte boundry

                c.skip(header - (pos+1));             // skip old padding

                Span defaultSkip = new Span(c.readU4());

                int low = c.readU4();

                int high = c.readU4();

                if (Inject.verbose) {

                    trace(" " + low + " to " + high);

                    trace(": default= [was] " + defaultSkip.target);

                    trace(" [now] " + defaultSkip.newTarget);

                    for (int i = low; i <= high; ++i) {

                        Span jump = new Span(c.readU4());

                        traceln("");

                        trace('\t');

                        traceFixedWidthInt(i, 5);

                        trace(": " + jump.newTarget);

                    }

                } else {

                    c.skip((high+1-low) * 4);

                }

                int newPadding = newHeader - newPos;

                int oldPadding = header - pos;

                int deltaPadding = newPadding - oldPadding;

                if (widened != deltaPadding) {

                    widen(pos, deltaPadding);

                    return false;       // cause restart

                }

                break;

            }

            case opc_lookupswitch:{

                int widened = widening[pos];

                int header = (pos+1+3) & (~3);        // 4byte boundry

                int newHeader = (newPos+1+3) & (~3);  // 4byte boundry

                c.skip(header - (pos+1));             // skip old padding

                Span defaultSkip = new Span(c.readU4());

                int npairs = c.readU4();

                if (Inject.verbose) {

                    trace(" npairs: " + npairs);

                    trace(": default= [was] " + defaultSkip.target);

                    trace(" [now] " + defaultSkip.newTarget);

                    for (int i = 0; i< npairs; ++i) {

                        int match = c.readU4();

                        Span jump = new Span(c.readU4());

                        traceln("");

                        trace('\t');

                        traceFixedWidthInt(match, 5);

                        trace(": " + jump.newTarget);

                    }

                } else {

                    c.skip(npairs * 8);

                }

                int newPadding = newHeader - newPos;

                int oldPadding = header - pos;

                int deltaPadding = newPadding - oldPadding;

                if (widened != deltaPadding) {

                    widen(pos, deltaPadding);

                    return false;       // cause restart

                }

                break;

            }

            case opc_jsr: case opc_goto:

            case opc_ifeq: case opc_ifge: case opc_ifgt:

            case opc_ifle: case opc_iflt: case opc_ifne:

            case opc_if_icmpeq: case opc_if_icmpne: case opc_if_icmpge:

            case opc_if_icmpgt: case opc_if_icmple: case opc_if_icmplt:

            case opc_if_acmpeq: case opc_if_acmpne:

            case opc_ifnull: case opc_ifnonnull: {

                int widened = widening[pos];

                Span jump = new Span(c.readS2());

                if (widened == 0) {  // not yet widened

                    int newDelta = jump.newDelta;

                    if ((newDelta < -32768) || (newDelta > 32767)) {

                        switch (opcode) {

                        case opc_jsr: case opc_goto:

                            widen(pos, 2); // will convert to wide

                            break;

                        default:

                            widen(pos, 5); // will inject goto_w

                            break;

                        }

                        return false;       // cause restart

                    }

                }

                if (Inject.verbose) {

                    trace(" [was] " + jump.target + " ==> " +

                          " [now] " + jump.newTarget);

                }

                break;

            }

            case opc_jsr_w:

            case opc_goto_w: {

                Span jump = new Span(c.readU4());

                if (Inject.verbose) {

                    trace(" [was] " + jump.target +

                          " [now] " + jump.newTarget);

                }

                break;

            }

            default: {

                int instrLen = opcLengths[opcode];

                c.skip(instrLen-1);

                break;

            }

            }

        }

        return true;     // successful return

    }

    /**

     * Walk one instruction writing the transformed instruction.

     */

    private void writeInstruction() throws IOException {

        pos = c.localPosition();

        newPos = map[pos];

        byte[] newCode = snippets.remove(new Integer(pos));

        if (newCode != null) {

            traceln();

            traceFixedWidthInt(pos, 4);

            trace(" ... -- Inserting new code");

            c.writeBytes(newCode);

        }

        int opcode = c.readU1();

        if (Inject.verbose) {

            traceln();

            traceFixedWidthInt(pos, 4);

            traceFixedWidthInt(newPos, 4);

            trace(" ");

        }

        if (opcode == opc_wide) {

            int wopcode = c.readU1();

            int lvIndex = c.readU2();

            if (Inject.verbose) {

                trace(opcNames[wopcode] + "_w ");

            }

            c.writeU1(opcode);

            c.writeU1(wopcode);

            c.writeU2(lvIndex);

            switch (wopcode) {

            case opc_aload: case opc_astore:

            case opc_fload: case opc_fstore:

            case opc_iload: case opc_istore:

            case opc_lload: case opc_lstore:

            case opc_dload: case opc_dstore:

            case opc_ret:

                trace(lvIndex);

                break;

            case opc_iinc:

                int constVal = c.readS2();

                c.writeU2(constVal);  // ??? U vs S

                if (Inject.verbose) {

                    trace(lvIndex + " " + constVal);

                }

                break;

            default:

                throw new Error("Invalid wide opcode: " + wopcode);

            }

        } else {

            if (Inject.verbose) {

                trace(opcNames[opcode]);

            }

            switch (opcode) {

            case opc_tableswitch:{

                int header = (pos+1+3) & (~3);   // 4byte boundry

                int newHeader = (newPos+1+3) & (~3); // 4byte boundry

                c.skip(header - (pos+1));             // skip old padding

                Span defaultSkip = new Span(c.readU4());

                int low = c.readU4();

                int high = c.readU4();

                c.writeU1(opcode);                   // copy instruction

                for (int i = newPos+1; i < newHeader; ++i) {

                    c.writeU1(0);                    // write new padding

                }

                c.writeU4(defaultSkip.newDelta);

                c.writeU4(low);

                c.writeU4(high);

                if (Inject.verbose) {

                    trace(" " + low + " to " + high);

                    trace(": default= [was] " + defaultSkip.target);

                    trace(" [now] " + defaultSkip.newTarget);

                }

                for (int i = low; i <= high; ++i) {

                    Span jump = new Span(c.readU4());

                    c.writeU4(jump.newDelta);

                    if (Inject.verbose) {

                        traceln("");

                        trace('\t');

                        traceFixedWidthInt(i, 5);

                        trace(": " + jump.newTarget);

                    }

                }

                break;

            }

            case opc_lookupswitch:{

                int header = (pos+1+3) & (~3);   // 4byte boundry

                int newHeader = (newPos+1+3) & (~3); // 4byte boundry

                c.skip(header - (pos+1));             // skip old padding

                Span defaultSkip = new Span(c.readU4());

                int npairs = c.readU4();

                if (Inject.verbose) {

                    trace(" npairs: " + npairs);

                    trace(": default= [was] " + defaultSkip.target);

                    trace(" [now] " + defaultSkip.newTarget);