mirror of
https://github.com/PaperMC/Paper.git
synced 2024-11-02 17:01:38 +01:00
899bc53b79
Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: f47abd88 SPIGOT-6242: Fix some file line endings de96535b SPIGOT-6234: enum classes don't serialize properly when implementing ConfigurationSerializable CraftBukkit Changes: 4475707d SPIGOT-6244: /spawnpoint ignores angle 8b3b096d SPIGOT-6242: Fix some file line endings 4b33c749 SPIGOT-6186: Canceling a CreatureSpawnEvent results in a "Unable to summon entity due to duplicate UUIDs" error 2b3ca726 SPIGOT-6236: Vehicle passenger portal cooldown does not change
441 lines
19 KiB
Diff
441 lines
19 KiB
Diff
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
|
From: Techcable <Techcable@outlook.com>
|
|
Date: Thu, 3 Mar 2016 13:20:33 -0700
|
|
Subject: [PATCH] Use ASM for event executors.
|
|
|
|
Uses method handles for private or static methods.
|
|
|
|
diff --git a/pom.xml b/pom.xml
|
|
index 30253c7c0da5c5940fab16df0f118e1b167712e8..01263d58c48324131b8feb20404174e1d40754a5 100644
|
|
--- a/pom.xml
|
|
+++ b/pom.xml
|
|
@@ -128,6 +128,17 @@
|
|
<version>8.0.1</version>
|
|
<scope>test</scope>
|
|
</dependency>
|
|
+ <!-- ASM -->
|
|
+ <dependency>
|
|
+ <groupId>org.ow2.asm</groupId>
|
|
+ <artifactId>asm</artifactId>
|
|
+ <version>8.0.1</version>
|
|
+ </dependency>
|
|
+ <dependency>
|
|
+ <groupId>org.ow2.asm</groupId>
|
|
+ <artifactId>asm-commons</artifactId>
|
|
+ <version>8.0.1</version>
|
|
+ </dependency>
|
|
</dependencies>
|
|
|
|
<build>
|
|
diff --git a/src/main/java/com/destroystokyo/paper/event/executor/MethodHandleEventExecutor.java b/src/main/java/com/destroystokyo/paper/event/executor/MethodHandleEventExecutor.java
|
|
new file mode 100644
|
|
index 0000000000000000000000000000000000000000..5b28e9b1daba7834af67dbc193dd656bedd9a994
|
|
--- /dev/null
|
|
+++ b/src/main/java/com/destroystokyo/paper/event/executor/MethodHandleEventExecutor.java
|
|
@@ -0,0 +1,42 @@
|
|
+package com.destroystokyo.paper.event.executor;
|
|
+
|
|
+import java.lang.invoke.MethodHandle;
|
|
+import java.lang.invoke.MethodHandles;
|
|
+import java.lang.reflect.Method;
|
|
+
|
|
+import com.destroystokyo.paper.util.SneakyThrow;
|
|
+import org.bukkit.event.Event;
|
|
+import org.bukkit.event.EventException;
|
|
+import org.bukkit.event.Listener;
|
|
+import org.bukkit.plugin.EventExecutor;
|
|
+import org.jetbrains.annotations.NotNull;
|
|
+
|
|
+public class MethodHandleEventExecutor implements EventExecutor {
|
|
+ private final Class<? extends Event> eventClass;
|
|
+ private final MethodHandle handle;
|
|
+
|
|
+ public MethodHandleEventExecutor(@NotNull Class<? extends Event> eventClass, @NotNull MethodHandle handle) {
|
|
+ this.eventClass = eventClass;
|
|
+ this.handle = handle;
|
|
+ }
|
|
+
|
|
+ public MethodHandleEventExecutor(@NotNull Class<? extends Event> eventClass, @NotNull Method m) {
|
|
+ this.eventClass = eventClass;
|
|
+ try {
|
|
+ m.setAccessible(true);
|
|
+ this.handle = MethodHandles.lookup().unreflect(m);
|
|
+ } catch (IllegalAccessException e) {
|
|
+ throw new AssertionError("Unable to set accessible", e);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ @Override
|
|
+ public void execute(@NotNull Listener listener, @NotNull Event event) throws EventException {
|
|
+ if (!eventClass.isInstance(event)) return;
|
|
+ try {
|
|
+ handle.invoke(listener, event);
|
|
+ } catch (Throwable t) {
|
|
+ SneakyThrow.sneaky(t);
|
|
+ }
|
|
+ }
|
|
+}
|
|
diff --git a/src/main/java/com/destroystokyo/paper/event/executor/StaticMethodHandleEventExecutor.java b/src/main/java/com/destroystokyo/paper/event/executor/StaticMethodHandleEventExecutor.java
|
|
new file mode 100644
|
|
index 0000000000000000000000000000000000000000..c83672427324bd068ed52916f700b68446a226f6
|
|
--- /dev/null
|
|
+++ b/src/main/java/com/destroystokyo/paper/event/executor/StaticMethodHandleEventExecutor.java
|
|
@@ -0,0 +1,43 @@
|
|
+package com.destroystokyo.paper.event.executor;
|
|
+
|
|
+import java.lang.invoke.MethodHandle;
|
|
+import java.lang.invoke.MethodHandles;
|
|
+import java.lang.reflect.Method;
|
|
+import java.lang.reflect.Modifier;
|
|
+
|
|
+import com.destroystokyo.paper.util.SneakyThrow;
|
|
+import com.google.common.base.Preconditions;
|
|
+
|
|
+import org.bukkit.Bukkit;
|
|
+import org.bukkit.event.Event;
|
|
+import org.bukkit.event.EventException;
|
|
+import org.bukkit.event.Listener;
|
|
+import org.bukkit.plugin.EventExecutor;
|
|
+import org.jetbrains.annotations.NotNull;
|
|
+
|
|
+public class StaticMethodHandleEventExecutor implements EventExecutor {
|
|
+ private final Class<? extends Event> eventClass;
|
|
+ private final MethodHandle handle;
|
|
+
|
|
+ public StaticMethodHandleEventExecutor(@NotNull Class<? extends Event> eventClass, @NotNull Method m) {
|
|
+ Preconditions.checkArgument(Modifier.isStatic(m.getModifiers()), "Not a static method: %s", m);
|
|
+ Preconditions.checkArgument(eventClass != null, "eventClass is null");
|
|
+ this.eventClass = eventClass;
|
|
+ try {
|
|
+ m.setAccessible(true);
|
|
+ this.handle = MethodHandles.lookup().unreflect(m);
|
|
+ } catch (IllegalAccessException e) {
|
|
+ throw new AssertionError("Unable to set accessible", e);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ @Override
|
|
+ public void execute(@NotNull Listener listener, @NotNull Event event) throws EventException {
|
|
+ if (!eventClass.isInstance(event)) return;
|
|
+ try {
|
|
+ handle.invoke(event);
|
|
+ } catch (Throwable throwable) {
|
|
+ SneakyThrow.sneaky(throwable);
|
|
+ }
|
|
+ }
|
|
+}
|
|
diff --git a/src/main/java/com/destroystokyo/paper/event/executor/asm/ASMEventExecutorGenerator.java b/src/main/java/com/destroystokyo/paper/event/executor/asm/ASMEventExecutorGenerator.java
|
|
new file mode 100644
|
|
index 0000000000000000000000000000000000000000..b6e7d8ee8d903ebf975d60bec0e08603d9a49fdb
|
|
--- /dev/null
|
|
+++ b/src/main/java/com/destroystokyo/paper/event/executor/asm/ASMEventExecutorGenerator.java
|
|
@@ -0,0 +1,47 @@
|
|
+package com.destroystokyo.paper.event.executor.asm;
|
|
+
|
|
+import java.lang.reflect.Method;
|
|
+import java.util.concurrent.atomic.AtomicInteger;
|
|
+
|
|
+import org.bukkit.plugin.EventExecutor;
|
|
+import org.jetbrains.annotations.NotNull;
|
|
+import org.objectweb.asm.ClassWriter;
|
|
+import org.objectweb.asm.Type;
|
|
+import org.objectweb.asm.commons.GeneratorAdapter;
|
|
+
|
|
+import static org.objectweb.asm.Opcodes.*;
|
|
+
|
|
+public class ASMEventExecutorGenerator {
|
|
+ @NotNull
|
|
+ public static byte[] generateEventExecutor(@NotNull Method m, @NotNull String name) {
|
|
+ ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
|
|
+ writer.visit(V1_8, ACC_PUBLIC, name.replace('.', '/'), null, Type.getInternalName(Object.class), new String[] {Type.getInternalName(EventExecutor.class)});
|
|
+ // Generate constructor
|
|
+ GeneratorAdapter methodGenerator = new GeneratorAdapter(writer.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null), ACC_PUBLIC, "<init>", "()V");
|
|
+ methodGenerator.loadThis();
|
|
+ methodGenerator.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(Object.class), "<init>", "()V", false); // Invoke the super class (Object) constructor
|
|
+ methodGenerator.returnValue();
|
|
+ methodGenerator.endMethod();
|
|
+ // Generate the execute method
|
|
+ methodGenerator = new GeneratorAdapter(writer.visitMethod(ACC_PUBLIC, "execute", "(Lorg/bukkit/event/Listener;Lorg/bukkit/event/Event;)V", null, null), ACC_PUBLIC, "execute", "(Lorg/bukkit/event/Listener;Lorg/bukkit/event/Listener;)V");;
|
|
+ methodGenerator.loadArg(0);
|
|
+ methodGenerator.checkCast(Type.getType(m.getDeclaringClass()));
|
|
+ methodGenerator.loadArg(1);
|
|
+ methodGenerator.checkCast(Type.getType(m.getParameterTypes()[0]));
|
|
+ methodGenerator.visitMethodInsn(m.getDeclaringClass().isInterface() ? INVOKEINTERFACE : INVOKEVIRTUAL, Type.getInternalName(m.getDeclaringClass()), m.getName(), Type.getMethodDescriptor(m), m.getDeclaringClass().isInterface());
|
|
+ if (m.getReturnType() != void.class) {
|
|
+ methodGenerator.pop();
|
|
+ }
|
|
+ methodGenerator.returnValue();
|
|
+ methodGenerator.endMethod();
|
|
+ writer.visitEnd();
|
|
+ return writer.toByteArray();
|
|
+ }
|
|
+
|
|
+ public static AtomicInteger NEXT_ID = new AtomicInteger(1);
|
|
+ @NotNull
|
|
+ public static String generateName() {
|
|
+ int id = NEXT_ID.getAndIncrement();
|
|
+ return "com.destroystokyo.paper.event.executor.asm.generated.GeneratedEventExecutor" + id;
|
|
+ }
|
|
+}
|
|
diff --git a/src/main/java/com/destroystokyo/paper/event/executor/asm/ClassDefiner.java b/src/main/java/com/destroystokyo/paper/event/executor/asm/ClassDefiner.java
|
|
new file mode 100644
|
|
index 0000000000000000000000000000000000000000..beed9e6e07a9080f1c059e08220839090553d0a4
|
|
--- /dev/null
|
|
+++ b/src/main/java/com/destroystokyo/paper/event/executor/asm/ClassDefiner.java
|
|
@@ -0,0 +1,35 @@
|
|
+package com.destroystokyo.paper.event.executor.asm;
|
|
+
|
|
+import com.destroystokyo.paper.utils.UnsafeUtils;
|
|
+import org.jetbrains.annotations.NotNull;
|
|
+
|
|
+public interface ClassDefiner {
|
|
+
|
|
+ /**
|
|
+ * Returns if the defined classes can bypass access checks
|
|
+ *
|
|
+ * @return if classes bypass access checks
|
|
+ */
|
|
+ public default boolean isBypassAccessChecks() {
|
|
+ return false;
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * Define a class
|
|
+ *
|
|
+ * @param parentLoader the parent classloader
|
|
+ * @param name the name of the class
|
|
+ * @param data the class data to load
|
|
+ * @return the defined class
|
|
+ * @throws ClassFormatError if the class data is invalid
|
|
+ * @throws NullPointerException if any of the arguments are null
|
|
+ */
|
|
+ @NotNull
|
|
+ public Class<?> defineClass(@NotNull ClassLoader parentLoader, @NotNull String name, @NotNull byte[] data);
|
|
+
|
|
+ @NotNull
|
|
+ public static ClassDefiner getInstance() {
|
|
+ return SafeClassDefiner.INSTANCE;
|
|
+ }
|
|
+
|
|
+}
|
|
diff --git a/src/main/java/com/destroystokyo/paper/event/executor/asm/SafeClassDefiner.java b/src/main/java/com/destroystokyo/paper/event/executor/asm/SafeClassDefiner.java
|
|
new file mode 100644
|
|
index 0000000000000000000000000000000000000000..ac99477e9f2c08041aeff31abc1d1edee58d0a67
|
|
--- /dev/null
|
|
+++ b/src/main/java/com/destroystokyo/paper/event/executor/asm/SafeClassDefiner.java
|
|
@@ -0,0 +1,66 @@
|
|
+package com.destroystokyo.paper.event.executor.asm;
|
|
+
|
|
+import java.util.concurrent.ConcurrentHashMap;
|
|
+import java.util.concurrent.ConcurrentMap;
|
|
+
|
|
+import com.google.common.base.Preconditions;
|
|
+
|
|
+import com.google.common.collect.MapMaker;
|
|
+import org.jetbrains.annotations.NotNull;
|
|
+import org.objectweb.asm.Type;
|
|
+
|
|
+public class SafeClassDefiner implements ClassDefiner {
|
|
+ /* default */ static final SafeClassDefiner INSTANCE = new SafeClassDefiner();
|
|
+
|
|
+ private SafeClassDefiner() {}
|
|
+
|
|
+ private final ConcurrentMap<ClassLoader, GeneratedClassLoader> loaders = new MapMaker().weakKeys().makeMap();
|
|
+
|
|
+ @NotNull
|
|
+ @Override
|
|
+ public Class<?> defineClass(@NotNull ClassLoader parentLoader, @NotNull String name, @NotNull byte[] data) {
|
|
+ GeneratedClassLoader loader = loaders.computeIfAbsent(parentLoader, GeneratedClassLoader::new);
|
|
+ synchronized (loader.getClassLoadingLock(name)) {
|
|
+ Preconditions.checkState(!loader.hasClass(name), "%s already defined", name);
|
|
+ Class<?> c = loader.define(name, data);
|
|
+ assert c.getName().equals(name);
|
|
+ return c;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ private static class GeneratedClassLoader extends ClassLoader {
|
|
+ static {
|
|
+ ClassLoader.registerAsParallelCapable();
|
|
+ }
|
|
+
|
|
+ protected GeneratedClassLoader(@NotNull ClassLoader parent) {
|
|
+ super(parent);
|
|
+ }
|
|
+
|
|
+ private Class<?> define(@NotNull String name, byte[] data) {
|
|
+ synchronized (getClassLoadingLock(name)) {
|
|
+ assert !hasClass(name);
|
|
+ Class<?> c = defineClass(name, data, 0, data.length);
|
|
+ resolveClass(c);
|
|
+ return c;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ @Override
|
|
+ @NotNull
|
|
+ public Object getClassLoadingLock(@NotNull String name) {
|
|
+ return super.getClassLoadingLock(name);
|
|
+ }
|
|
+
|
|
+ public boolean hasClass(@NotNull String name) {
|
|
+ synchronized (getClassLoadingLock(name)) {
|
|
+ try {
|
|
+ Class.forName(name);
|
|
+ return true;
|
|
+ } catch (ClassNotFoundException e) {
|
|
+ return false;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+}
|
|
diff --git a/src/main/java/com/destroystokyo/paper/utils/UnsafeUtils.java b/src/main/java/com/destroystokyo/paper/utils/UnsafeUtils.java
|
|
new file mode 100644
|
|
index 0000000000000000000000000000000000000000..72e48e8efdf750d77fc1f9d5fa7dc279e88aa9a7
|
|
--- /dev/null
|
|
+++ b/src/main/java/com/destroystokyo/paper/utils/UnsafeUtils.java
|
|
@@ -0,0 +1,35 @@
|
|
+package com.destroystokyo.paper.utils;
|
|
+
|
|
+import org.jetbrains.annotations.Nullable;
|
|
+import sun.misc.Unsafe;
|
|
+
|
|
+import java.lang.reflect.Field;
|
|
+
|
|
+public class UnsafeUtils {
|
|
+ private UnsafeUtils() {}
|
|
+
|
|
+ private static final Unsafe UNSAFE;
|
|
+ static {
|
|
+ Unsafe unsafe;
|
|
+ try {
|
|
+ Class c = Class.forName("sun.misc.Unsafe");
|
|
+ Field f = c.getDeclaredField("theUnsafe");
|
|
+ f.setAccessible(true);
|
|
+ unsafe = (Unsafe) f.get(null);
|
|
+ } catch (ClassNotFoundException | NoSuchFieldException | SecurityException e) {
|
|
+ unsafe = null;
|
|
+ } catch (IllegalAccessException e) {
|
|
+ throw new AssertionError(e);
|
|
+ }
|
|
+ UNSAFE = unsafe;
|
|
+ }
|
|
+
|
|
+ public static boolean isUnsafeSupported() {
|
|
+ return UNSAFE != null;
|
|
+ }
|
|
+
|
|
+ @Nullable
|
|
+ public static Unsafe getUnsafe() {
|
|
+ return UNSAFE;
|
|
+ }
|
|
+}
|
|
diff --git a/src/main/java/org/bukkit/plugin/EventExecutor.java b/src/main/java/org/bukkit/plugin/EventExecutor.java
|
|
index a850f0780de05463fc0d3f9e15ff7f19d88b2aed..9026e108ccd3a88aee1267ee275137befa646455 100644
|
|
--- a/src/main/java/org/bukkit/plugin/EventExecutor.java
|
|
+++ b/src/main/java/org/bukkit/plugin/EventExecutor.java
|
|
@@ -5,9 +5,75 @@ import org.bukkit.event.EventException;
|
|
import org.bukkit.event.Listener;
|
|
import org.jetbrains.annotations.NotNull;
|
|
|
|
+// Paper start
|
|
+import java.lang.reflect.Method;
|
|
+import java.lang.reflect.Modifier;
|
|
+import java.util.concurrent.ConcurrentHashMap;
|
|
+import java.util.concurrent.ConcurrentMap;
|
|
+import java.util.function.Function;
|
|
+
|
|
+import com.destroystokyo.paper.event.executor.MethodHandleEventExecutor;
|
|
+import com.destroystokyo.paper.event.executor.StaticMethodHandleEventExecutor;
|
|
+import com.destroystokyo.paper.event.executor.asm.ASMEventExecutorGenerator;
|
|
+import com.destroystokyo.paper.event.executor.asm.ClassDefiner;
|
|
+import com.google.common.base.Preconditions;
|
|
+// Paper end
|
|
+
|
|
/**
|
|
* Interface which defines the class for event call backs to plugins
|
|
*/
|
|
public interface EventExecutor {
|
|
public void execute(@NotNull Listener listener, @NotNull Event event) throws EventException;
|
|
+
|
|
+ // Paper start
|
|
+ ConcurrentMap<Method, Class<? extends EventExecutor>> eventExecutorMap = new ConcurrentHashMap<Method, Class<? extends EventExecutor>>() {
|
|
+ @NotNull
|
|
+ @Override
|
|
+ public Class<? extends EventExecutor> computeIfAbsent(@NotNull Method key, @NotNull Function<? super Method, ? extends Class<? extends EventExecutor>> mappingFunction) {
|
|
+ Class<? extends EventExecutor> executorClass = get(key);
|
|
+ if (executorClass != null)
|
|
+ return executorClass;
|
|
+
|
|
+ //noinspection SynchronizationOnLocalVariableOrMethodParameter
|
|
+ synchronized (key) {
|
|
+ executorClass = get(key);
|
|
+ if (executorClass != null)
|
|
+ return executorClass;
|
|
+
|
|
+ return super.computeIfAbsent(key, mappingFunction);
|
|
+ }
|
|
+ }
|
|
+ };
|
|
+
|
|
+ @NotNull
|
|
+ public static EventExecutor create(@NotNull Method m, @NotNull Class<? extends Event> eventClass) {
|
|
+ Preconditions.checkNotNull(m, "Null method");
|
|
+ Preconditions.checkArgument(m.getParameterCount() != 0, "Incorrect number of arguments %s", m.getParameterCount());
|
|
+ Preconditions.checkArgument(m.getParameterTypes()[0] == eventClass, "First parameter %s doesn't match event class %s", m.getParameterTypes()[0], eventClass);
|
|
+ ClassDefiner definer = ClassDefiner.getInstance();
|
|
+ if (Modifier.isStatic(m.getModifiers())) {
|
|
+ return new StaticMethodHandleEventExecutor(eventClass, m);
|
|
+ } else if (definer.isBypassAccessChecks() || Modifier.isPublic(m.getDeclaringClass().getModifiers()) && Modifier.isPublic(m.getModifiers())) {
|
|
+ // get the existing generated EventExecutor class for the Method or generate one
|
|
+ Class<? extends EventExecutor> executorClass = eventExecutorMap.computeIfAbsent(m, (__) -> {
|
|
+ String name = ASMEventExecutorGenerator.generateName();
|
|
+ byte[] classData = ASMEventExecutorGenerator.generateEventExecutor(m, name);
|
|
+ return definer.defineClass(m.getDeclaringClass().getClassLoader(), name, classData).asSubclass(EventExecutor.class);
|
|
+ });
|
|
+
|
|
+ try {
|
|
+ EventExecutor asmExecutor = executorClass.newInstance();
|
|
+ // Define a wrapper to conform to bukkit stupidity (passing in events that don't match and wrapper exception)
|
|
+ return (listener, event) -> {
|
|
+ if (!eventClass.isInstance(event)) return;
|
|
+ asmExecutor.execute(listener, event);
|
|
+ };
|
|
+ } catch (InstantiationException | IllegalAccessException e) {
|
|
+ throw new AssertionError("Unable to initialize generated event executor", e);
|
|
+ }
|
|
+ } else {
|
|
+ return new MethodHandleEventExecutor(eventClass, m);
|
|
+ }
|
|
+ }
|
|
+ // Paper end
|
|
}
|
|
diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
|
|
index c8497cb3021f584a885f4cb21c3be576ce0935a7..5be6460e8eb81381c7e305cb7ab6b77c0c7a8fe5 100644
|
|
--- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
|
|
+++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
|
|
@@ -300,21 +300,7 @@ public final class JavaPluginLoader implements PluginLoader {
|
|
}
|
|
}
|
|
|
|
- EventExecutor executor = new co.aikar.timings.TimedEventExecutor(new EventExecutor() { // Paper
|
|
- @Override
|
|
- public void execute(@NotNull Listener listener, @NotNull Event event) throws EventException { // Paper
|
|
- try {
|
|
- if (!eventClass.isAssignableFrom(event.getClass())) {
|
|
- return;
|
|
- }
|
|
- method.invoke(listener, event);
|
|
- } catch (InvocationTargetException ex) {
|
|
- throw new EventException(ex.getCause());
|
|
- } catch (Throwable t) {
|
|
- throw new EventException(t);
|
|
- }
|
|
- }
|
|
- }, plugin, method, eventClass); // Paper
|
|
+ EventExecutor executor = new co.aikar.timings.TimedEventExecutor(EventExecutor.create(method, eventClass), plugin, method, eventClass); // Paper // Paper (Yes.) - Use factory method `EventExecutor.create()`
|
|
if (false) { // Spigot - RL handles useTimings check now
|
|
eventSet.add(new TimedRegisteredListener(listener, executor, eh.priority(), plugin, eh.ignoreCancelled()));
|
|
} else {
|