From 084e176e7cde8e724e7c8bb83ea4400e0f40ae58 Mon Sep 17 00:00:00 2001 From: Raven Szewczyk Date: Thu, 19 Jan 2023 13:15:12 +0000 Subject: [PATCH] Copy ExtensibleEnumTransformer from modern forge --- .../common/util/EnumHelper.java | 282 ++++++++++++++++++ .../core/ExtensibleEnumTransformerHelper.java | 213 +++++++++++++ .../UnfinalizeObjectHoldersTransformer.java | 14 + 3 files changed, 509 insertions(+) create mode 100644 src/forgePatches/java/net/minecraftforge/common/util/EnumHelper.java create mode 100644 src/main/java/me/eigenraven/lwjgl3ify/core/ExtensibleEnumTransformerHelper.java diff --git a/src/forgePatches/java/net/minecraftforge/common/util/EnumHelper.java b/src/forgePatches/java/net/minecraftforge/common/util/EnumHelper.java new file mode 100644 index 0000000..2eaf8d5 --- /dev/null +++ b/src/forgePatches/java/net/minecraftforge/common/util/EnumHelper.java @@ -0,0 +1,282 @@ +package net.minecraftforge.common.util; + +import cpw.mods.fml.common.FMLLog; +import java.lang.reflect.*; +import java.util.*; +import net.minecraft.block.BlockPressurePlate.Sensitivity; +import net.minecraft.block.material.Material; +import net.minecraft.enchantment.EnumEnchantmentType; +import net.minecraft.entity.Entity.EnumEntitySize; +import net.minecraft.entity.EnumCreatureAttribute; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.entity.item.EntityPainting.EnumArt; +import net.minecraft.entity.player.EntityPlayer.EnumStatus; +import net.minecraft.item.EnumAction; +import net.minecraft.item.EnumRarity; +import net.minecraft.item.Item.ToolMaterial; +import net.minecraft.item.ItemArmor.ArmorMaterial; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.MovingObjectPosition.MovingObjectType; +import net.minecraft.world.EnumSkyBlock; +import net.minecraft.world.gen.structure.StructureStrongholdPieces.Stronghold.Door; +import net.minecraftforge.classloading.FMLForgePlugin; +import sun.misc.Unsafe; + +public class EnumHelper { + private static Object reflectionFactory = null; + private static Method newConstructorAccessor = null; + private static Method newInstance = null; + private static Method newFieldAccessor = null; + private static Method fieldAccessorSet = null; + private static boolean isSetup = false; + + // Some enums are decompiled with extra arguments, so lets check for that + @SuppressWarnings("rawtypes") + private static Class[][] commonTypes = { + {EnumAction.class}, + {ArmorMaterial.class, int.class, int[].class, int.class}, + {EnumArt.class, String.class, int.class, int.class, int.class, int.class}, + {EnumCreatureAttribute.class}, + {EnumCreatureType.class, Class.class, int.class, Material.class, boolean.class, boolean.class}, + {Door.class}, + {EnumEnchantmentType.class}, + {EnumEntitySize.class}, + {Sensitivity.class}, + {MovingObjectType.class}, + {EnumSkyBlock.class, int.class}, + {EnumStatus.class}, + {ToolMaterial.class, int.class, int.class, float.class, float.class, int.class}, + {EnumRarity.class, EnumChatFormatting.class, String.class} + }; + + public static EnumAction addAction(String name) { + return addEnum(EnumAction.class, name); + } + + public static ArmorMaterial addArmorMaterial( + String name, int durability, int[] reductionAmounts, int enchantability) { + return addEnum(ArmorMaterial.class, name, durability, reductionAmounts, enchantability); + } + + public static EnumArt addArt(String name, String tile, int sizeX, int sizeY, int offsetX, int offsetY) { + return addEnum(EnumArt.class, name, tile, sizeX, sizeY, offsetX, offsetY); + } + + public static EnumCreatureAttribute addCreatureAttribute(String name) { + return addEnum(EnumCreatureAttribute.class, name); + } + + @SuppressWarnings("rawtypes") + public static EnumCreatureType addCreatureType( + String name, Class typeClass, int maxNumber, Material material, boolean peaceful, boolean animal) { + return addEnum(EnumCreatureType.class, name, typeClass, maxNumber, material, peaceful, animal); + } + + public static Door addDoor(String name) { + return addEnum(Door.class, name); + } + + public static EnumEnchantmentType addEnchantmentType(String name) { + return addEnum(EnumEnchantmentType.class, name); + } + + public static EnumEntitySize addEntitySize(String name) { + return addEnum(EnumEntitySize.class, name); + } + + public static Sensitivity addSensitivity(String name) { + return addEnum(Sensitivity.class, name); + } + + public static MovingObjectType addMovingObjectType(String name) { + return addEnum(MovingObjectType.class, name); + } + + public static EnumSkyBlock addSkyBlock(String name, int lightValue) { + return addEnum(EnumSkyBlock.class, name, lightValue); + } + + public static EnumStatus addStatus(String name) { + return addEnum(EnumStatus.class, name); + } + + public static ToolMaterial addToolMaterial( + String name, int harvestLevel, int maxUses, float efficiency, float damage, int enchantability) { + return addEnum(ToolMaterial.class, name, harvestLevel, maxUses, efficiency, damage, enchantability); + } + + public static EnumRarity addRarity(String name, EnumChatFormatting color, String displayName) { + return addEnum(EnumRarity.class, name, color, displayName); + } + + private static Unsafe unsafe; + + private static void setup() { + if (isSetup) { + return; + } + + try { + if (unsafe == null) { + final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe"); + unsafeField.setAccessible(true); + unsafe = (Unsafe) unsafeField.get(null); + } + } catch (Exception e) { + e.printStackTrace(); + } + + isSetup = true; + } + + /* + * Everything below this is found at the site below, and updated to be able to compile in Eclipse/Java 1.6+ + * Also modified for use in decompiled code. + * Found at: http://niceideas.ch/roller2/badtrash/entry/java_create_enum_instances_dynamically + */ + private static Object getConstructorAccessor(Class enumClass, Class[] additionalParameterTypes) + throws Exception { + Class[] parameterTypes = new Class[additionalParameterTypes.length + 2]; + parameterTypes[0] = String.class; + parameterTypes[1] = int.class; + System.arraycopy(additionalParameterTypes, 0, parameterTypes, 2, additionalParameterTypes.length); + return newConstructorAccessor.invoke(reflectionFactory, enumClass.getDeclaredConstructor(parameterTypes)); + } + + private static > T makeEnum( + Class enumClass, String value, int ordinal, Class[] additionalTypes, Object[] additionalValues) + throws Exception { + Object[] parms = new Object[additionalValues.length + 2]; + parms[0] = value; + parms[1] = Integer.valueOf(ordinal); + System.arraycopy(additionalValues, 0, parms, 2, additionalValues.length); + return enumClass.cast( + newInstance.invoke(getConstructorAccessor(enumClass, additionalTypes), new Object[] {parms})); + } + + public static void setFailsafeFieldValue(Field field, Object target, Object value) throws Exception { + field.setAccessible(true); + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); + modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL); + Object fieldAccessor = newFieldAccessor.invoke(reflectionFactory, field, false); + fieldAccessorSet.invoke(fieldAccessor, target, value); + } + + private static void blankField(Class enumClass, String fieldName) throws Exception { + for (Field field : Class.class.getDeclaredFields()) { + if (field.getName().contains(fieldName)) { + field.setAccessible(true); + setFailsafeFieldValue(field, enumClass, null); + break; + } + } + } + + private static void cleanEnumCache(Class enumClass) throws Exception { + blankField(enumClass, "enumConstantDirectory"); + blankField(enumClass, "enumConstants"); + } + + public static > T addEnum(Class enumType, String enumName, Object... paramValues) { + setup(); + return addEnum(commonTypes, enumType, enumName, paramValues); + } + + @SuppressWarnings("rawtypes") + public static > T addEnum( + Class[][] map, Class enumType, String enumName, Object... paramValues) { + for (Class[] lookup : map) { + if (lookup[0] == enumType) { + Class[] paramTypes = new Class[lookup.length - 1]; + if (paramTypes.length > 0) { + System.arraycopy(lookup, 1, paramTypes, 0, paramTypes.length); + } + return addEnum(enumType, enumName, paramTypes, paramValues); + } + } + return null; + } + + @SuppressWarnings("unchecked") + public static > T addEnum( + Class enumType, String enumName, Class[] paramTypes, Object[] paramValues) { + if (!isSetup) { + setup(); + } + + Field valuesField = null; + Field[] fields = enumType.getDeclaredFields(); + + for (Field field : fields) { + String name = field.getName(); + if (name.equals("$VALUES") + || name.equals( + "ENUM$VALUES")) // Added 'ENUM$VALUES' because Eclipse's internal compiler doesn't follow + // standards + { + valuesField = field; + break; + } + } + + int flags = (FMLForgePlugin.RUNTIME_DEOBF ? Modifier.PUBLIC : Modifier.PRIVATE) + | Modifier.STATIC + | Modifier.FINAL + | 0x1000 /*SYNTHETIC*/; + if (valuesField == null) { + String valueType = String.format("[L%s;", enumType.getName().replace('.', '/')); + + for (Field field : fields) { + if ((field.getModifiers() & flags) == flags + && field.getType() + .getName() + .replace('.', '/') + .equals(valueType)) // Apparently some JVMs return .'s and some don't.. + { + valuesField = field; + break; + } + } + } + + if (valuesField == null) { + FMLLog.severe("Could not find $VALUES field for enum: %s", enumType.getName()); + FMLLog.severe("Runtime Deobf: %s", FMLForgePlugin.RUNTIME_DEOBF); + FMLLog.severe( + "Flags: %s", + String.format("%16s", Integer.toBinaryString(flags)).replace(' ', '0')); + FMLLog.severe("Fields:"); + for (Field field : fields) { + String mods = String.format("%16s", Integer.toBinaryString(field.getModifiers())) + .replace(' ', '0'); + FMLLog.severe( + " %s %s: %s", + mods, field.getName(), field.getType().getName()); + } + return null; + } + + valuesField.setAccessible(true); + + try { + T[] previousValues = (T[]) valuesField.get(enumType); + List values = new ArrayList(Arrays.asList(previousValues)); + T newValue = (T) makeEnum(enumType, enumName, values.size(), paramTypes, paramValues); + values.add(newValue); + setFailsafeFieldValue(valuesField, null, values.toArray((T[]) Array.newInstance(enumType, 0))); + cleanEnumCache(enumType); + + return newValue; + } catch (Exception e) { + e.printStackTrace(); + throw new RuntimeException(e.getMessage(), e); + } + } + + static { + if (!isSetup) { + setup(); + } + } +} diff --git a/src/main/java/me/eigenraven/lwjgl3ify/core/ExtensibleEnumTransformerHelper.java b/src/main/java/me/eigenraven/lwjgl3ify/core/ExtensibleEnumTransformerHelper.java new file mode 100644 index 0000000..1ce89e8 --- /dev/null +++ b/src/main/java/me/eigenraven/lwjgl3ify/core/ExtensibleEnumTransformerHelper.java @@ -0,0 +1,213 @@ +/* + * Copyright (c) Forge Development LLC and contributors + * SPDX-License-Identifier: LGPL-2.1-only + */ +package me.eigenraven.lwjgl3ify.core; + +import java.util.List; +import java.util.stream.Collectors; + +import org.apache.logging.log4j.Logger; +import org.objectweb.asm.Label; +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.Type; +import org.objectweb.asm.commons.InstructionAdapter; +import org.objectweb.asm.tree.ClassNode; +import org.objectweb.asm.tree.FieldNode; +import org.objectweb.asm.tree.MethodNode; + +public class ExtensibleEnumTransformerHelper { + private final Logger LOGGER = Lwjgl3ifyCoremod.LOGGER; + private final Type STRING = Type.getType(String.class); + private final Type ENUM = Type.getType(Enum.class); + private final Type MARKER_IFACE = Type.getType("Lnet/minecraftforge/common/IExtensibleEnum;"); + private final Type ARRAY_UTILS = Type.getType("Lorg/apache/commons/lang3/ArrayUtils;"); //Don't directly reference this to prevent class loading. + private final String ADD_DESC = Type.getMethodDescriptor(Type.getType(Object[].class), Type.getType(Object[].class), Type.getType(Object.class)); + private final Type UNSAFE_HACKS = Type.getType("Lnet/minecraftforge/fml/unsafe/UnsafeHacks;"); //Again, not direct reference to prevent class loading. + private final String CLEAN_DESC = Type.getMethodDescriptor(Type.VOID_TYPE, Type.getType(Class.class)); + private final String NAME_DESC = Type.getMethodDescriptor(STRING); + private final String EQUALS_DESC = Type.getMethodDescriptor(Type.BOOLEAN_TYPE, STRING); + + /** + * @return Were changes made? + */ + public boolean processClassWithFlags(final ClassNode classNode, final Type classType) + { + if ((classNode.access & Opcodes.ACC_ENUM) == 0) + return false; + + Type array = Type.getType("[" + classType.getDescriptor()); + final int flags = Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC; + + FieldNode values = classNode.fields.stream().filter(f -> f.desc.contentEquals(array.getDescriptor()) && ((f.access & flags) == flags)).findFirst().orElse(null); + + if (!classNode.interfaces.contains(MARKER_IFACE.getInternalName())) { + return false; + } + + //Static methods named "create" with first argument as a string + List candidates = classNode.methods.stream() + .filter(m -> ((m.access & Opcodes.ACC_STATIC) != 0) && m.name.equals("create")) + .collect(Collectors.toList()); + + if (candidates.isEmpty()) { + throw new IllegalStateException("IExtensibleEnum has no candidate factory methods: " + classType.getClassName()); + } + + candidates.forEach(mtd -> + { + Type[] args = Type.getArgumentTypes(mtd.desc); + if (args.length == 0 || !args[0].equals(STRING)) { + if (LOGGER.isErrorEnabled()) + { + String sb = "Enum has create method without String as first parameter:\n" + + " Enum: " + classType.getDescriptor() + "\n" + + " Target: " + mtd.name + mtd.desc + "\n"; + LOGGER.error(sb); + } + throw new IllegalStateException("Enum has create method without String as first parameter: " + mtd.name + mtd.desc); + } + + Type ret = Type.getReturnType(mtd.desc); + if (!ret.equals(classType)) { + if (LOGGER.isErrorEnabled()) + { + String sb = "Enum has create method with incorrect return type:\n" + + " Enum: " + classType.getDescriptor() + "\n" + + " Target: " + mtd.name + mtd.desc + "\n" + + " Found: " + ret.getClassName() + ", Expected: " + classType.getClassName(); + LOGGER.error(sb); + } + throw new IllegalStateException("Enum has create method with incorrect return type: " + mtd.name + mtd.desc); + } + + Type[] ctrArgs = new Type[args.length + 1]; + ctrArgs[0] = STRING; + ctrArgs[1] = Type.INT_TYPE; + for (int x = 1; x < args.length; x++) + ctrArgs[1 + x] = args[x]; + + String desc = Type.getMethodDescriptor(Type.VOID_TYPE, ctrArgs); + + MethodNode ctr = classNode.methods.stream().filter(m -> m.name.equals("") && m.desc.equals(desc)).findFirst().orElse(null); + if (ctr == null) + { + if (LOGGER.isErrorEnabled()) + { + StringBuilder sb = new StringBuilder(); + sb.append("Enum has create method with no matching constructor:\n"); + sb.append(" Enum: ").append(classType.getDescriptor()).append("\n"); + sb.append(" Candidate: ").append(mtd.desc).append("\n"); + sb.append(" Target: ").append(desc).append("\n"); + classNode.methods.stream().filter(m -> m.name.equals("")).forEach(m -> sb.append(" : ").append(m.desc).append("\n")); + LOGGER.error(sb.toString()); + } + throw new IllegalStateException("Enum has create method with no matching constructor: " + desc); + } + + if (values == null) + { + if (LOGGER.isErrorEnabled()) + { + StringBuilder sb = new StringBuilder(); + sb.append("Enum has create method but we could not find $VALUES. Found:\n"); + classNode.fields.stream().filter(f -> (f.access & Opcodes.ACC_STATIC) != 0). + forEach(m -> sb.append(" ").append(m.name).append(" ").append(m.desc).append("\n")); + LOGGER.error(sb.toString()); + } + throw new IllegalStateException("Enum has create method but we could not find $VALUES"); + } + + values.access &= values.access & ~Opcodes.ACC_FINAL; //Strip the final so JITer doesn't inline things. + + mtd.access |= Opcodes.ACC_SYNCHRONIZED; + mtd.instructions.clear(); + mtd.localVariables.clear(); + if (mtd.tryCatchBlocks != null) + { + mtd.tryCatchBlocks.clear(); + } + if (mtd.visibleLocalVariableAnnotations != null) + { + mtd.visibleLocalVariableAnnotations.clear(); + } + if (mtd.invisibleLocalVariableAnnotations != null) + { + mtd.invisibleLocalVariableAnnotations.clear(); + } + InstructionAdapter ins = new InstructionAdapter(mtd); + + int vars = 0; + for (Type arg : args) + vars += arg.getSize(); + + { + vars += 1; //int x + Label for_start = new Label(); + Label for_condition = new Label(); + Label for_inc = new Label(); + + ins.iconst(0); + ins.store(vars, Type.INT_TYPE); + ins.goTo(for_condition); + //if (!VALUES[x].name().equalsIgnoreCase(name)) goto for_inc + ins.mark(for_start); + ins.getstatic(classType.getInternalName(), values.name, values.desc); + ins.load(vars, Type.INT_TYPE); + ins.aload(array); + ins.invokevirtual(ENUM.getInternalName(), "name", NAME_DESC, false); + ins.load(0, STRING); + ins.invokevirtual(STRING.getInternalName(), "equalsIgnoreCase", EQUALS_DESC, false); + ins.ifeq(for_inc); + //return VALUES[x]; + ins.getstatic(classType.getInternalName(), values.name, values.desc); + ins.load(vars, Type.INT_TYPE); + ins.aload(array); + ins.areturn(classType); + //x++ + ins.mark(for_inc); + ins.iinc(vars, 1); + //if (x < VALUES.length) goto for_start + ins.mark(for_condition); + ins.load(vars, Type.INT_TYPE); + ins.getstatic(classType.getInternalName(), values.name, values.desc); + ins.arraylength(); + ins.ificmplt(for_start); + } + + { + vars += 1; //enum ret; + //ret = new ThisType(name, VALUES.length, args..) + ins.anew(classType); + ins.dup(); + ins.load(0, STRING); + ins.getstatic(classType.getInternalName(), values.name, values.desc); + ins.arraylength(); + int idx = 1; + for (int x = 1; x < args.length; x++) + { + ins.load(idx, args[x]); + idx += args[x].getSize(); + } + ins.invokespecial(classType.getInternalName(), "", desc, false); + ins.store(vars, classType); + // VALUES = ArrayUtils.add(VALUES, ret) + ins.getstatic(classType.getInternalName(), values.name, values.desc); + ins.load(vars, classType); + ins.invokestatic(ARRAY_UTILS.getInternalName(), "add", ADD_DESC, false); + ins.checkcast(array); + ins.putstatic(classType.getInternalName(), values.name, values.desc); + //EnumHelper.cleanEnumCache(ThisType.class) + ins.visitLdcInsn(classType); + ins.invokestatic(UNSAFE_HACKS.getInternalName(), "cleanEnumCache", CLEAN_DESC, false); + //init ret + ins.load(vars, classType); + ins.invokeinterface(MARKER_IFACE.getInternalName(), "init", "()V"); + //return ret + ins.load(vars, classType); + ins.areturn(classType); + } + }); + return true; + } +} diff --git a/src/main/java/me/eigenraven/lwjgl3ify/core/UnfinalizeObjectHoldersTransformer.java b/src/main/java/me/eigenraven/lwjgl3ify/core/UnfinalizeObjectHoldersTransformer.java index daa298e..e0ac84c 100644 --- a/src/main/java/me/eigenraven/lwjgl3ify/core/UnfinalizeObjectHoldersTransformer.java +++ b/src/main/java/me/eigenraven/lwjgl3ify/core/UnfinalizeObjectHoldersTransformer.java @@ -4,11 +4,14 @@ import net.minecraft.launchwrapper.IClassTransformer; import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassWriter; import org.objectweb.asm.Opcodes; +import org.objectweb.asm.Type; import org.objectweb.asm.tree.AnnotationNode; import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.FieldNode; public class UnfinalizeObjectHoldersTransformer implements IClassTransformer { + final ExtensibleEnumTransformerHelper enumTransformer = new ExtensibleEnumTransformerHelper(); + @Override public byte[] transform(String name, String transformedName, byte[] basicClass) { if (basicClass == null) { @@ -18,6 +21,7 @@ public class UnfinalizeObjectHoldersTransformer implements IClassTransformer { final ClassReader reader = new ClassReader(basicClass); final ClassNode node = new ClassNode(); reader.accept(node, ClassReader.EXPAND_FRAMES); + final Type classType = Type.getType("L" + transformedName.replace('.', '/') + ";"); boolean transformClass = false; boolean workDone = false; @@ -64,6 +68,16 @@ public class UnfinalizeObjectHoldersTransformer implements IClassTransformer { } if (workDone) { Lwjgl3ifyCoremod.LOGGER.info("Unfinalized {} Holder fields in {}", fieldsModified, transformedName); + } + + final boolean enumsTransformed = enumTransformer.processClassWithFlags(node, classType); + + if (enumsTransformed) { + workDone = true; + Lwjgl3ifyCoremod.LOGGER.info("Dynamicized enum {}", transformedName); + } + + if (workDone) { final ClassWriter writer = new ClassWriter(0); node.accept(writer); return writer.toByteArray();