Subversion Repositories openrisc

/**

 * ASM: a very small and fast Java bytecode manipulation framework

 * Copyright (c) 2000-2005 INRIA, France Telecom

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the copyright holders nor the names of its

 *    contributors may be used to endorse or promote products derived from

 *    this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

package org.objectweb.asm.attrs;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.objectweb.asm.Attribute;

import org.objectweb.asm.ByteVector;

import org.objectweb.asm.ClassReader;

import org.objectweb.asm.ClassWriter;

import org.objectweb.asm.Label;

/**

 * StackMapAttribute is used by CDLC preverifier. Definition is given in

 * appendix "CLDC Byte Code Typechecker Specification" from CDLC 1.1

 * specification. <p> <i>Note that this implementation does not calculate

 * StackMapFrame structures from the method bytecode. If method code is changed

 * or generated from scratch, then developer is responsible to prepare a correct

 * StackMapFrame structures.</i> <p> The format of the stack map in the class

 * file is given below. In the following, <ul> <li>if the length of the

 * method's byte code1 is 65535 or less, then <tt>uoffset</tt> represents the

 * type u2; otherwise <tt>uoffset</tt> represents the type u4.</li> <li>If

 * the maximum number of local variables for the method is 65535 or less, then

 * <tt>ulocalvar</tt> represents the type u2; otherwise <tt>ulocalvar</tt>

 * represents the type u4.</li> <li>If the maximum size of the operand stack

 * is 65535 or less, then <tt>ustack</tt> represents the type u2; otherwise

 * ustack represents the type u4.</li> </ul>

 *

 * <pre>

 * stack_map { // attribute StackMap

 *   u2 attribute_name_index;

 *   u4 attribute_length

 *   uoffset number_of_entries;

 *   stack_map_frame entries[number_of_entries];

 * }

 * </pre>

 *

 * Each stack map frame has the following format:

 *

 * <pre>

 * stack_map_frame {

 *   uoffset offset;

 *   ulocalvar number_of_locals;

 *   verification_type_info locals[number_of_locals];

 *   ustack number_of_stack_items;

 *   verification_type_info stack[number_of_stack_items];

 * }

 * </pre>

 *

 * The <tt>verification_type_info</tt> structure consists of a one-byte tag

 * followed by zero or more bytes, giving more information about the tag. Each

 * <tt>verification_type_info</tt> structure specifies the verification type

 * of one or two locations.

 *

 * <pre>

 * union verification_type_info {

 *   Top_variable_info;

 *   Integer_variable_info;

 *   Float_variable_info;

 *   Long_variable_info;

 *   Double_variable_info;

 *   Null_variable_info;

 *   UninitializedThis_variable_info;

 *   Object_variable_info;

 *   Uninitialized_variable_info;

 * }

 *

 * Top_variable_info {

 *   u1 tag = ITEM_Top; // 0

 * }

 *

 * Integer_variable_info {

 *   u1 tag = ITEM_Integer; // 1

 * }

 *

 * Float_variable_info {

 *   u1 tag = ITEM_Float; // 2

 * }

 *

 * Long_variable_info {

 *   u1 tag = ITEM_Long; // 4

 * }

 *

 * Double_variable_info {

 *   u1 tag = ITEM_Double; // 3

 * }

 *

 * Null_variable_info {

 *  u1 tag = ITEM_Null; // 5

 * }

 *

 * UninitializedThis_variable_info {

 *   u1 tag = ITEM_UninitializedThis; // 6

 * }

 *

 * Object_variable_info {

 *   u1 tag = ITEM_Object; // 7

 *   u2 cpool_index;

 * }

 *

 * Uninitialized_variable_info {

 *   u1 tag = ITEM_Uninitialized // 8

 *   uoffset offset;

 * }

 * </pre>

 *

 * @see <a href="http://www.jcp.org/en/jsr/detail?id=139">JSR 139 : Connected

 *      Limited Device Configuration 1.1</a>

 *

 * @author Eugene Kuleshov

 */

public class StackMapAttribute extends Attribute {

    static final int MAX_SIZE = 65535;

    /**

     * A List of <code>StackMapFrame</code> instances.

     */

    public List frames = new ArrayList();

    public StackMapAttribute() {

        super("StackMap");

    }

    public StackMapAttribute(List frames) {

        this();

        this.frames = frames;

    }

    public List getFrames() {

        return frames;

    }

    public StackMapFrame getFrame(Label label) {

        for (int i = 0; i < frames.size(); i++) {

            StackMapFrame frame = (StackMapFrame) frames.get(i);

            if (frame.label == label) {

                return frame;

            }

        }

        return null;

    }

    public boolean isUnknown() {

        return false;

    }

    public boolean isCodeAttribute() {

        return true;

    }

    protected Attribute read(

        ClassReader cr,

        int off,

        int len,

        char[] buf,

        int codeOff,

        Label[] labels)

    {

        StackMapAttribute attr = new StackMapAttribute();

        // note that this is not the size of Code attribute

        boolean isExtCodeSize = cr.readInt(codeOff + 4) > MAX_SIZE;

        boolean isExtLocals = cr.readUnsignedShort(codeOff + 2) > MAX_SIZE;

        boolean isExtStack = cr.readUnsignedShort(codeOff) > MAX_SIZE;

        int size = 0;

        if (isExtCodeSize) {

            size = cr.readInt(off);

            off += 4;

        } else {

            size = cr.readUnsignedShort(off);

            off += 2;

        }

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

            int offset;

            if (isExtCodeSize) {

                offset = cr.readInt(off);

                off += 4;

            } else {

                offset = cr.readUnsignedShort(off);

                off += 2;

            }

            Label label = getLabel(offset, labels);

            List locals = new ArrayList();

            List stack = new ArrayList();

            off = readTypeInfo(cr,

                    off,

                    locals,

                    labels,

                    buf,

                    isExtLocals,

                    isExtCodeSize);

            off = readTypeInfo(cr,

                    off,

                    stack,

                    labels,

                    buf,

                    isExtStack,

                    isExtCodeSize);

            attr.frames.add(new StackMapFrame(label, locals, stack));

        }

        return attr;

    }

    private int readTypeInfo(

        ClassReader cr,

        int off,

        List info,

        Label[] labels,

        char[] buf,

        boolean isExt,

        boolean isExtCode)

    {

        int n = 0;

        if (isExt) {

            n = cr.readInt(off);

            off += 4;

        } else {

            n = cr.readUnsignedShort(off);

            off += 2;

        }

        for (int j = 0; j < n; j++) {

            int itemType = cr.readByte(off++);

            StackMapType typeInfo = StackMapType.getTypeInfo(itemType);

            info.add(typeInfo);

            switch (itemType) {

                case StackMapType.ITEM_Object: //

                    typeInfo.setObject(cr.readClass(off, buf));

                    off += 2;

                    break;

                case StackMapType.ITEM_Uninitialized: //

                    int offset;

                    if (isExtCode) {

                        offset = cr.readInt(off);

                        off += 4;

                    } else {

                        offset = cr.readUnsignedShort(off);

                        off += 2;

                    }

                    typeInfo.setLabel(getLabel(offset, labels));

                    break;

            }

        }

        return off;

    }

    private void writeTypeInfo(ByteVector bv, ClassWriter cw, List info, int max)

    {

        if (max > StackMapAttribute.MAX_SIZE) {

            bv.putInt(info.size());

        } else {

            bv.putShort(info.size());

        }

        for (int j = 0; j < info.size(); j++) {

            StackMapType typeInfo = (StackMapType) info.get(j);

            bv.putByte(typeInfo.getType());

            switch (typeInfo.getType()) {

                case StackMapType.ITEM_Object: //

                    bv.putShort(cw.newClass(typeInfo.getObject()));

                    break;

                case StackMapType.ITEM_Uninitialized: //

                    bv.putShort(typeInfo.getLabel().getOffset());

                    break;

            }

        }

    }

    private Label getLabel(int offset, Label[] labels) {

        Label l = labels[offset];

        if (l != null) {

            return l;

        }

        return labels[offset] = new Label();

    }

    protected ByteVector write(

        ClassWriter cw,

        byte[] code,

        int len,

        int maxStack,

        int maxLocals)

    {

        ByteVector bv = new ByteVector();

        if (code != null && code.length > MAX_SIZE) { // TODO verify value

            bv.putInt(frames.size());

        } else {

            bv.putShort(frames.size());

        }

        for (int i = 0; i < frames.size(); i++) {

            writeFrame((StackMapFrame) frames.get(i),

                    cw,

                    maxStack,

                    maxLocals,

                    bv);

        }

        return bv;

    }

    protected Label[] getLabels() {

        HashSet labels = new HashSet();

        for (int i = 0; i < frames.size(); i++) {

            getFrameLabels((StackMapFrame) frames.get(i), labels);

        }

        return (Label[]) labels.toArray(new Label[labels.size()]);

    }

    private void writeFrame(

        StackMapFrame frame,

        ClassWriter cw,

        int maxStack,

        int maxLocals,

        ByteVector bv)

    {

        bv.putShort(frame.label.getOffset());

        writeTypeInfo(bv, cw, frame.locals, maxLocals);

        writeTypeInfo(bv, cw, frame.stack, maxStack);

    }

    private void getFrameLabels(StackMapFrame frame, Set labels) {

        labels.add(frame.label);

        getTypeInfoLabels(labels, frame.locals);

        getTypeInfoLabels(labels, frame.stack);

    }

    private void getTypeInfoLabels(Set labels, List info) {

        for (Iterator it = info.iterator(); it.hasNext();) {

            StackMapType typeInfo = (StackMapType) it.next();

            if (typeInfo.getType() == StackMapType.ITEM_Uninitialized) {

                labels.add(typeInfo.getLabel());

            }

        }

    }

    public String toString() {

        StringBuffer sb = new StringBuffer("StackMap[");

        for (int i = 0; i < frames.size(); i++) {

            sb.append('\n').append('[').append(frames.get(i)).append(']');

        }

        sb.append("\n]");

        return sb.toString();

    }

}