hazendaz / jmockit1 / 496

Committed 15 Nov 2025 05:33PM UTC coverage: 72.192% (-0.008%) from 72.2%

Build # 496

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #412 from hazendaz/renovate/major-spring-core

Update spring core to v7 (major)

Run Details

5677 of 8360 branches covered (67.91%)

Branch coverage included in aggregate %.

11922 of 16018 relevant lines covered (74.43%)

0.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.14

/main/src/main/java/mockit/asm/constantPool/ConstantPoolGeneration.java

/*
 * MIT License
 * Copyright (c) 2006-2025 JMockit developers
 * See LICENSE file for full license text.
 */
package mockit.asm.constantPool;

import static mockit.asm.jvmConstants.ConstantPoolTypes.CLASS;
import static mockit.asm.jvmConstants.ConstantPoolTypes.DOUBLE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.FIELD_REF;
import static mockit.asm.jvmConstants.ConstantPoolTypes.FLOAT;
import static mockit.asm.jvmConstants.ConstantPoolTypes.IMETHOD_REF;
import static mockit.asm.jvmConstants.ConstantPoolTypes.INTEGER;
import static mockit.asm.jvmConstants.ConstantPoolTypes.LONG;
import static mockit.asm.jvmConstants.ConstantPoolTypes.METHOD_HANDLE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.METHOD_REF;
import static mockit.asm.jvmConstants.ConstantPoolTypes.METHOD_TYPE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.NAME_TYPE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.STRING;
import static mockit.asm.jvmConstants.ConstantPoolTypes.UTF8;
import static mockit.internal.util.ClassLoad.OBJECT;

import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;

import mockit.asm.jvmConstants.ConstantPoolTypes;
import mockit.asm.types.JavaType;
import mockit.asm.types.MethodType;
import mockit.asm.types.PrimitiveType;
import mockit.asm.types.ReferenceType;
import mockit.asm.util.ByteVector;
import mockit.asm.util.MethodHandle;
import mockit.internal.util.ClassLoad;

import org.checkerframework.checker.index.qual.NonNegative;

/**
 * Allows the constant pool for a classfile to be created from scratch, when that classfile itself is being generated or
 * modified from an existing class file.
 */
@SuppressWarnings({ "ClassWithTooManyFields", "OverlyCoupledClass" })
public final class ConstantPoolGeneration {
    /**
     * The constant pool of the class file being generated/modified.
     */
    @NonNull
    private final ByteVector pool;

    /**
     * The constant pool's hash table data.
     */
    @NonNull
    private Item[] items;

    /**
     * The threshold of the constant pool's hash table.
     */
    @NonNegative
    private int threshold;

    /**
     * Index of the next item to be added in the constant pool.
     */
    @NonNegative
    private int index;

    @NonNull
    private final StringItem reusableUTF8Item;
    @NonNull
    private final StringItem reusableStringItem;
    @NonNull
    private final NameAndTypeItem reusableNameTypeItem;
    @NonNull
    private final ClassMemberItem reusableClassMemberItem;
    @NonNull
    private final IntItem reusableIntItem;
    @NonNull
    private final LongItem reusableLongItem;
    @NonNull
    private final FloatItem reusableFloatItem;
    @NonNull
    private final DoubleItem reusableDoubleItem;
    @NonNull
    private final MethodHandleItem reusableMethodHandleItem;
    @NonNull
    private final DynamicItem reusableDynamicItem;

    /**
     * A type table used to temporarily store internal names that will not necessarily be stored in the constant pool.
     * This type table is used by the control flow and data flow analysis algorithm to compute stack map frames from
     * scratch. This array associates to each index <code>i</code> the <code>TypeTableItem</code> whose index is
     * <code>i</code>. All <code>TypeTableItem</code> objects stored in this array are also stored in the {@link #items}
     * hash table. These two arrays allow to retrieve an <code>Item</code> from its index or, conversely, to get the
     * index of an <code>Item</code> from its value. Each <code>TypeTableItem</code> stores an internal name in its
     * {@link TypeTableItem#typeDesc} field.
     */
    private TypeTableItem[] typeTable;

    /**
     * Number of elements in the {@link #typeTable} array.
     */
    private short typeCount;

    @NonNull
    private final NormalTypeTableItem reusableNormalItem;
    @NonNull
    private final UninitializedTypeTableItem reusableUninitializedItem;
    @NonNull
    private final MergedTypeTableItem reusableMergedItem;

    @SuppressWarnings("OverlyCoupledMethod")
    public ConstantPoolGeneration() {
        pool = new ByteVector();
        items = new Item[256];
        // noinspection NumericCastThatLosesPrecision
        threshold = (int) (0.75d * items.length);
        index = 1;
        reusableUTF8Item = new StringItem();
        reusableStringItem = new StringItem();
        reusableNameTypeItem = new NameAndTypeItem(0);
        reusableClassMemberItem = new ClassMemberItem(0);
        reusableIntItem = new IntItem(0);
        reusableLongItem = new LongItem(0);
        reusableFloatItem = new FloatItem(0);
        reusableDoubleItem = new DoubleItem(0);
        reusableMethodHandleItem = new MethodHandleItem(0);
        reusableDynamicItem = new DynamicItem(0);
        reusableNormalItem = new NormalTypeTableItem();
        reusableUninitializedItem = new UninitializedTypeTableItem();
        reusableMergedItem = new MergedTypeTableItem();
    }

    /**
     * Adds an UTF8 string to the constant pool of the class being built. Does nothing if the constant pool already
     * contains a similar item.
     *
     * @param value
     *            the String value.
     *
     * @return the index of a new or already existing UTF8 item.
     */
    @NonNegative
    public int newUTF8(@NonNull String value) {
        reusableUTF8Item.set(UTF8, value);

        StringItem result = get(reusableUTF8Item);

        if (result == null) {
            pool.putByte(UTF8).putUTF8(value);

            result = new StringItem(index++, reusableUTF8Item);
            put(result);
        }

        return result.index;
    }

    /**
     * Adds a class reference to the constant pool of the class being built. Does nothing if the constant pool already
     * contains a similar item.
     *
     * @param internalName
     *            the internal name of the class.
     *
     * @return the index of a new or already existing class reference item.
     */
    @NonNegative
    public int newClass(@NonNull String internalName) {
        return newClassItem(internalName).index;
    }

    /**
     * Adds a class reference to the constant pool of the class being built. Does nothing if the constant pool already
     * contains a similar item.
     *
     * @param internalName
     *            the internal name of the class.
     *
     * @return a new or already existing class reference item.
     */
    @NonNull
    public StringItem newClassItem(@NonNull String internalName) {
        return newStringItem(CLASS, internalName);
    }

    /**
     * Adds a string to the constant pool of the class being built. Does nothing if the constant pool already contains a
     * similar item.
     *
     * @param type
     *            one of {@link ConstantPoolTypes#STRING}, {@link ConstantPoolTypes#CLASS} or
     *            {@link ConstantPoolTypes#METHOD_TYPE}
     * @param value
     *            the String value.
     *
     * @return a new or already existing string item.
     */
    @NonNull
    private StringItem newStringItem(int type, @NonNull String value) {
        reusableStringItem.set(type, value);

        StringItem result = get(reusableStringItem);

        if (result == null) {
            int itemIndex = newUTF8(value);
            pool.put12(type, itemIndex);

            result = new StringItem(index++, reusableStringItem);
            put(result);
        }

        return result;
    }

    /**
     * Adds a method handle to the constant pool of the class being built. Does nothing if the constant pool already
     * contains a similar item.
     *
     * @return a new or an already existing method type reference item.
     */
    @NonNull
    public MethodHandleItem newMethodHandleItem(@NonNull MethodHandle methodHandle) {
        reusableMethodHandleItem.set(methodHandle);

        MethodHandleItem result = get(reusableMethodHandleItem);

        if (result == null) {
            int tag = methodHandle.tag;
            int memberType = tag == MethodHandle.Tag.TAG_INVOKEINTERFACE ? IMETHOD_REF : METHOD_REF;
            ClassMemberItem memberItem = newClassMemberItem(memberType, methodHandle.owner, methodHandle.name,
                    methodHandle.desc);
            pool.put11(METHOD_HANDLE, tag).putShort(memberItem.index);

            result = new MethodHandleItem(index++, reusableMethodHandleItem);
            put(result);
        }

        return result;
    }

    @NonNull
    private ClassMemberItem newClassMemberItem(int type, @NonNull String owner, @NonNull String name,
            @NonNull String desc) {
        reusableClassMemberItem.set(type, owner, name, desc);

        ClassMemberItem result = get(reusableClassMemberItem);

        if (result == null) {
            int ownerItemIndex = newClass(owner);
            int nameAndTypeItemIndex = newNameType(name, desc);
            put122(type, ownerItemIndex, nameAndTypeItemIndex);

            result = new ClassMemberItem(index++, reusableClassMemberItem);
            put(result);
        }

        return result;
    }

    /**
     * Adds a field reference to the constant pool of the class being built. Does nothing if the constant pool already
     * contains a similar item.
     *
     * @param owner
     *            the internal name of the field's owner class
     * @param name
     *            the field's name
     * @param desc
     *            the field's descriptor
     *
     * @return a new or already existing field reference item
     */
    @NonNull
    public ClassMemberItem newFieldItem(@NonNull String owner, @NonNull String name, @NonNull String desc) {
        return newClassMemberItem(FIELD_REF, owner, name, desc);
    }

    /**
     * Adds a method reference to the constant pool of the class being built. Does nothing if the constant pool already
     * contains a similar item.
     *
     * @param owner
     *            the internal name of the method's owner class
     * @param name
     *            the method's name
     * @param desc
     *            the method's descriptor
     * @param itf
     *            <code>true</code> if <code>owner</code> is an interface
     *
     * @return a new or already existing method reference item
     */
    @NonNull
    public ClassMemberItem newMethodItem(@NonNull String owner, @NonNull String name, @NonNull String desc,
            boolean itf) {
        return newClassMemberItem(itf ? IMETHOD_REF : METHOD_REF, owner, name, desc);
    }

    /**
     * Adds an integer to the constant pool of the class being built. Does nothing if the constant pool already contains
     * a similar item.
     *
     * @param value
     *            the int value
     *
     * @return a new or already existing int item
     */
    @NonNull
    public IntItem newInteger(int value) {
        reusableIntItem.setValue(value);

        IntItem result = get(reusableIntItem);

        if (result == null) {
            pool.putByte(INTEGER).putInt(value);

            result = new IntItem(index++, reusableIntItem);
            put(result);
        }

        return result;
    }

    /**
     * Adds a float to the constant pool of the class being built. Does nothing if the constant pool already contains a
     * similar item.
     *
     * @param value
     *            the float value
     *
     * @return a new or already existing float item
     */
    @NonNull
    public FloatItem newFloat(float value) {
        reusableFloatItem.set(value);

        FloatItem result = get(reusableFloatItem);

        if (result == null) {
            pool.putByte(FLOAT).putInt(reusableFloatItem.intVal);

            result = new FloatItem(index++, reusableFloatItem);
            put(result);
        }

        return result;
    }

    /**
     * Adds a long to the constant pool of the class being built. Does nothing if the constant pool already contains a
     * similar item.
     *
     * @param value
     *            the long value
     *
     * @return a new or already existing long item
     */
    @NonNull
    public LongItem newLong(long value) {
        reusableLongItem.setValue(value);

        LongItem result = get(reusableLongItem);

        if (result == null) {
            pool.putByte(LONG).putLong(value);

            result = new LongItem(index, reusableLongItem);
            index += 2;
            put(result);
        }

        return result;
    }

    /**
     * Adds a double to the constant pool of the class being built. Does nothing if the constant pool already contains a
     * similar item.
     *
     * @param value
     *            the double value
     *
     * @return a new or already existing double item
     */
    @NonNull
    public DoubleItem newDouble(double value) {
        reusableDoubleItem.set(value);

        DoubleItem result = get(reusableDoubleItem);

        if (result == null) {
            pool.putByte(DOUBLE).putLong(reusableDoubleItem.longVal);

            result = new DoubleItem(index, reusableDoubleItem);
            index += 2;
            put(result);
        }

        return result;
    }

    /**
     * Adds a name and type to the constant pool of the class being built. Does nothing if the constant pool already
     * contains a similar item.
     *
     * @param name
     *            a name
     * @param desc
     *            a type descriptor
     *
     * @return the index of a new or already existing name and type item
     */
    @NonNegative
    private int newNameType(@NonNull String name, @NonNull String desc) {
        reusableNameTypeItem.set(name, desc);

        NameAndTypeItem result = get(reusableNameTypeItem);

        if (result == null) {
            int nameItemIndex = newUTF8(name);
            int descItemIndex = newUTF8(desc);
            put122(NAME_TYPE, nameItemIndex, descItemIndex);

            result = new NameAndTypeItem(index++, reusableNameTypeItem);
            put(result);
        }

        return result.index;
    }

    /**
     * Adds a number or string constant to the constant pool of the class being built. Does nothing if the constant pool
     * already contains a similar item.
     *
     * @param cst
     *            the value of the constant to be added to the constant pool, which must be an {@link Integer}, a
     *            {@link Float}, a {@link Long}, a {@link Double}, a {@link String}, or a {@link JavaType}
     *
     * @return a new or already existing constant item with the given value
     */
    @NonNull
    public Item newConstItem(@NonNull Object cst) {
        if (cst instanceof String) {
            return newStringItem(STRING, (String) cst);
        }

        if (cst instanceof Number) {
            return newNumberItem((Number) cst);
        }

        if (cst instanceof Character) {
            return newInteger((Character) cst);
        }

        if (cst instanceof Boolean) {
            int val = (boolean) cst ? 1 : 0;
            return newInteger(val);
        }

        if (cst instanceof ReferenceType) {
            String typeDesc = ((ReferenceType) cst).getInternalName();
            return cst instanceof MethodType ? newStringItem(METHOD_TYPE, typeDesc) : newClassItem(typeDesc);
        }

        if (cst instanceof PrimitiveType) {
            String typeDesc = ((PrimitiveType) cst).getDescriptor();
            return newClassItem(typeDesc);
        }

        if (cst instanceof MethodHandle) {
            return newMethodHandleItem((MethodHandle) cst);
        }

        if (cst instanceof DynamicItem) {
            DynamicItem dynamicItem = (DynamicItem) cst;
            return createDynamicItem(dynamicItem.type, dynamicItem.name, dynamicItem.desc, dynamicItem.bsmIndex);
        }
        throw new IllegalArgumentException("value " + cst);
    }

    @NonNull
    private Item newNumberItem(@NonNull Number cst) {
        if (cst instanceof Float) {
            return newFloat(cst.floatValue());
        }

        if (cst instanceof Long) {
            return newLong(cst.longValue());
        }

        if (cst instanceof Double) {
            return newDouble(cst.doubleValue());
        }

        return newInteger(cst.intValue());
    }

    /**
     * Adds the given internal name to {@link #typeTable} and returns its index. Does nothing if the type table already
     * contains this internal name.
     *
     * @param type
     *            the internal name to be added to the type table
     *
     * @return the index of this internal name in the type table
     */
    @NonNegative
    public int addNormalType(@NonNull String type) {
        reusableNormalItem.set(type);

        TypeTableItem result = get(reusableNormalItem);

        if (result == null) {
            result = new NormalTypeTableItem(++typeCount, reusableNormalItem);
            addToTypeTable(result);
        }

        return result.index;
    }

    /**
     * Adds the given "uninitialized" type to {@link #typeTable} and returns its index. This method is used for
     * UNINITIALIZED types, made of an internal name and a bytecode offset.
     *
     * @param type
     *            the internal name to be added to the type table
     * @param offset
     *            the bytecode offset of the NEW instruction that created this UNINITIALIZED type value
     *
     * @return the index of this internal name in the type table
     */
    @NonNegative
    public int addUninitializedType(@NonNull String type, @NonNegative int offset) {
        reusableUninitializedItem.set(type, offset);

        TypeTableItem result = get(reusableUninitializedItem);

        if (result == null) {
            result = new UninitializedTypeTableItem(++typeCount, reusableUninitializedItem);
            addToTypeTable(result);
        }

        return result.index;
    }

    private void addToTypeTable(@NonNull TypeTableItem newItem) {
        put(newItem);

        if (typeTable == null) {
            typeTable = new TypeTableItem[16];
        }

        int newItemIndex = typeCount;
        enlargeTypeTableIfNeeded(newItemIndex);
        typeTable[newItemIndex] = newItem;
    }

    private void enlargeTypeTableIfNeeded(@NonNegative int newItemIndex) {
        int currentTypeCount = typeTable.length;

        if (newItemIndex == currentTypeCount) {
            TypeTableItem[] newTable = new TypeTableItem[2 * currentTypeCount];
            System.arraycopy(typeTable, 0, newTable, 0, currentTypeCount);
            typeTable = newTable;
        }
    }

    /**
     * Returns the index of the common super type of the two given types. This method calls {@link #getCommonSuperClass}
     * and caches the result in the {@link #items} hash table to speedup future calls with the same parameters.
     *
     * @param type1
     *            index of an internal name in {@link #typeTable}
     * @param type2
     *            index of an internal name in {@link #typeTable}
     *
     * @return the index of the common super type of the two given types
     */
    @NonNegative
    public int getMergedType(@NonNegative int type1, @NonNegative int type2) {
        reusableMergedItem.set(type1, type2);

        MergedTypeTableItem result = get(reusableMergedItem);

        if (result == null) {
            String type1Desc = getInternalName(type1);
            String type2Desc = getInternalName(type2);
            String commonSuperClass = getCommonSuperClass(type1Desc, type2Desc);
            reusableMergedItem.commonSuperTypeIndex = addNormalType(commonSuperClass);

            result = new MergedTypeTableItem(reusableMergedItem);
            put(result);
        }

        return result.commonSuperTypeIndex;
    }

    /**
     * Returns the common super type of the two given types. The default implementation of this method <i>loads</i> the
     * two given classes and uses the java.lang.Class methods to find the common super class. It can be overridden to
     * compute this common super type in other ways, in particular without actually loading any class, or to take into
     * account the class that is currently being generated by this ClassWriter, which can of course not be loaded since
     * it is under construction.
     *
     * @param type1
     *            the internal name of a class
     * @param type2
     *            the internal name of another class
     *
     * @return the internal name of the common super class of the two given classes
     */
    @NonNull
    private static String getCommonSuperClass(@NonNull String type1, @NonNull String type2) {
        // Reimplemented to avoid "duplicate class definition" errors.
        String class1 = type1;
        String class2 = type2;

        while (true) {
            if (OBJECT.equals(class1) || OBJECT.equals(class2)) {
                return OBJECT;
            }

            String superClass = ClassLoad.whichIsSuperClass(class1, class2);

            if (superClass != null) {
                return superClass;
            }

            class1 = ClassLoad.getSuperClass(class1);
            class2 = ClassLoad.getSuperClass(class2);

            if (class1.equals(class2)) {
                return class1;
            }
        }
    }

    @NonNull
    public String getInternalName(@NonNegative int typeTableIndex) {
        TypeTableItem typeTableItem = typeTable[typeTableIndex]; // Normal or Uninitialized
        return typeTableItem.typeDesc;
    }

    @NonNull
    public UninitializedTypeTableItem getUninitializedItemValue(@NonNegative int typeTableIndex) {
        return (UninitializedTypeTableItem) typeTable[typeTableIndex];
    }

    @Nullable
    public Item getItem(@NonNegative int itemHashCode) {
        return items[itemHashCode % items.length];
    }

    /**
     * Returns the constant pool's hash table item which is equal to the given item.
     *
     * @param key
     *            a constant pool item
     *
     * @return the constant pool's hash table item which is equal to the given item, or <code>null</code> if there is no
     *         such item
     */
    @Nullable
    private <I extends Item> I get(@NonNull I key) {
        Item item = getItem(key.getHashCode());
        int keyType = key.getType();

        while (item != null && (item.getType() != keyType || !key.isEqualTo(item))) {
            item = item.getNext();
        }

        // noinspection unchecked
        return (I) item;
    }

    /**
     * Puts the given item in the constant pool's hash table. The hash table <i>must</i> not already contains this item.
     *
     * @param item
     *            the item to be added to the constant pool's hash table
     */
    private void put(@NonNull Item item) {
        resizeItemArrayIfNeeded();
        item.setNext(items);
    }

    private void resizeItemArrayIfNeeded() {
        if (index + typeCount > threshold) {
            int ll = items.length;
            int nl = ll * 2 + 1;
            Item[] newItems = new Item[nl];

            for (int l = ll - 1; l >= 0; l--) {
                Item j = items[l];
                put(newItems, j);
            }

            items = newItems;
            // noinspection NumericCastThatLosesPrecision
            threshold = (int) (nl * 0.75);
        }
    }

    private static void put(@NonNull Item[] newItems, @Nullable Item item) {
        while (item != null) {
            Item next = item.getNext();
            item.setNext(newItems);
            // noinspection AssignmentToMethodParameter
            item = next;
        }
    }

    /**
     * Puts one byte and two shorts into the constant pool.
     */
    private void put122(int b, int s1, int s2) {
        pool.put12(b, s1).putShort(s2);
    }

    @NonNegative
    public int getSize() {
        return pool.getLength();
    }

    public void checkConstantPoolMaxSize() {
        if (index > 0xFFFF) {
            throw new RuntimeException("Class file too large!");
        }
    }

    public void put(@NonNull ByteVector out) {
        out.putShort(index).putByteVector(pool);
    }

    public void copy(@NonNull byte[] code, @NonNegative int off, @NonNegative int header, @NonNull Item[] cpItems) {
        pool.putByteArray(code, off, header - off);
        items = cpItems;

        int ll = cpItems.length;
        // noinspection NumericCastThatLosesPrecision
        threshold = (int) (0.75d * ll);
        index = ll;
    }

    @NonNull
    public DynamicItem createDynamicItem(int type, @NonNull String name, @NonNull String desc,
            @NonNegative int bsmIndex) {
        reusableDynamicItem.set(type, name, desc, bsmIndex);

        DynamicItem result = get(reusableDynamicItem);

        if (result == null) {
            int nameAndTypeItemIndex = newNameType(name, desc);
            put122(type, bsmIndex, nameAndTypeItemIndex);

            result = new DynamicItem(index++, reusableDynamicItem);
            put(result);
        }

        return result;
    }
}

hazendaz / jmockit1 / 496

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous