adding ProfilingHandlerList, some refactoring and minor fixes

Mumfrey
1 parent f709bce8
Showing 10 changed files with 483 additions and 83 deletions
.classpath
debug/obfuscation.properties
java/client/com/mumfrey/liteloader/client/LiteLoaderEventBrokerClient.java
java/client/com/mumfrey/liteloader/util/ModUtilities.java
java/common/com/mumfrey/liteloader/core/event/HandlerList.java
java/common/com/mumfrey/liteloader/core/event/IHandlerListDecorator.java
java/common/com/mumfrey/liteloader/core/event/ProfilingHandlerList.java
java/common/com/mumfrey/liteloader/core/runtime/Obf.java
java/common/com/mumfrey/liteloader/transformers/ByteCodeUtilities.java
java/common/com/mumfrey/liteloader/util/ObfuscationUtilities.java
@@ -18,7 +18,7 @@
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/net/java/jinput/jinput/2.0.5/jinput-2.0.5.jar"/>
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/com/mojang/authlib/1.5.17/authlib-1.5.17.jar"/>
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/org/lwjgl/lwjgl/lwjgl/2.9.1/lwjgl-2.9.1.jar"/>
-	<classpathentry exported="true" kind="lib" path="lib/asm-debug-all-5.0.3.jar" sourcepath="/ASM/src"/>
+	<classpathentry exported="true" kind="lib" path="lib/asm-debug-all-5.0.3.jar"/>
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/org/lwjgl/lwjgl/lwjgl_util/2.9.1/lwjgl_util-2.9.1.jar"/>
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/com/mojang/realms/1.5.5/realms-1.5.5.jar"/>
 	<classpathentry kind="output" path="bin"/>
@@ -19,6 +19,7 @@ field_147712_ad=shaderResourceLocations
 field_147713_ae=shaderIndex
 field_175083_ad=useShader
 field_149528_b=view
+field_70163_u=posY
 func_148833_a=processPacket
 func_71411_J=runGameLoop
 func_71407_l=runTick
@@ -60,4 +61,5 @@ func_147346_a=processPlayerBlockPlacement
 func_175087_a=handleAnimation
 func_147345_a=processPlayerDigging
 func_71190_q=updateTimeLightAndEntities
-func_180031_a=checkThreadAndEnqueue
 \ No newline at end of file
+func_180031_a=checkThreadAndEnqueue
+func_147347_a=processPlayer
 \ No newline at end of file
@@ -19,6 +19,7 @@ import net.minecraft.util.Timer;
 import org.lwjgl.input.Mouse;
 import com.mumfrey.liteloader.*;
+import com.mumfrey.liteloader.client.overlays.IEntityRenderer;
 import com.mumfrey.liteloader.client.overlays.IMinecraft;
 import com.mumfrey.liteloader.common.LoadingProgress;
 import com.mumfrey.liteloader.core.InterfaceRegistrationDelegate;
@@ -26,6 +27,7 @@ import com.mumfrey.liteloader.core.LiteLoader;
 import com.mumfrey.liteloader.core.LiteLoaderEventBroker;
 import com.mumfrey.liteloader.core.event.HandlerList;
 import com.mumfrey.liteloader.core.event.HandlerList.ReturnLogicOp;
+import com.mumfrey.liteloader.core.event.ProfilingHandlerList;
 import com.mumfrey.liteloader.interfaces.FastIterableDeque;
 import com.mumfrey.liteloader.launch.LoaderProperties;
 import com.mumfrey.liteloader.transformers.event.EventInfo;
@@ -62,7 +64,7 @@ public class LiteLoaderEventBrokerClient extends LiteLoaderEventBroker&lt;Minecraft
 	 */
 	private int worldHashCode = 0;
-	private FastIterableDeque<Tickable>             tickListeners         = new HandlerList<Tickable>(Tickable.class);
+	private FastIterableDeque<Tickable>             tickListeners;
 	private FastIterableDeque<GameLoopListener>     loopListeners         = new HandlerList<GameLoopListener>(GameLoopListener.class);
 	private FastIterableDeque<RenderListener>       renderListeners       = new HandlerList<RenderListener>(RenderListener.class);
 	private FastIterableDeque<PostRenderListener>   postRenderListeners   = new HandlerList<PostRenderListener>(PostRenderListener.class);
@@ -84,6 +86,7 @@ public class LiteLoaderEventBrokerClient extends LiteLoaderEventBroker&lt;Minecraft
 		LiteLoaderEventBrokerClient.instance = this;
 		this.engineClient = (GameEngineClient)engine;
+		this.tickListeners = new ProfilingHandlerList<Tickable>(Tickable.class, this.engineClient.getProfiler());
 	}
 	static LiteLoaderEventBrokerClient getInstance()
@@ -302,6 +305,7 @@ public class LiteLoaderEventBrokerClient extends LiteLoaderEventBroker&lt;Minecraft
 	 */
 	void postRender(float partialTicks, long timeSlice)
 	{
+		((IEntityRenderer)this.engineClient.getClient().entityRenderer).setupCamera(partialTicks, 0);
 		this.postRenderListeners.all().onPostRender(partialTicks);
 	}
@@ -377,7 +381,7 @@ public class LiteLoaderEventBrokerClient extends LiteLoaderEventBroker&lt;Minecraft
 	 */
 	void onTick()
 	{
-		this.profiler.startSection("litemods");
+		this.profiler.endStartSection("litemods");
 		Timer minecraftTimer = ((IMinecraft)this.engine.getClient()).getTimer();
 		float partialTicks = minecraftTimer.renderPartialTicks;
@@ -408,8 +412,6 @@ public class LiteLoaderEventBrokerClient extends LiteLoaderEventBroker&lt;Minecraft
 			this.worldHashCode = worldHashCode;
 			super.onWorldChanged(minecraft.theWorld);
 		}
-		
-		this.profiler.endSection();
 	}
 	/**
@@ -43,7 +43,7 @@ public abstract class ModUtilities
 	 */
 	public static boolean fmlIsPresent()
 	{
-		return Obf.fmlIsPresent();
+		return ObfuscationUtilities.fmlIsPresent();
 	}
     public static void setWindowSize(int width, int height)
@@ -212,10 +212,12 @@ public abstract class ModUtilities
 	 * 
 	 * @param fieldName Name of field to get, returned unmodified if in debug mode
 	 * @return Obfuscated field name if present
+	 * @deprecated use ObfuscationUtilities.getObfuscatedFieldName instead
 	 */
+	@Deprecated
 	public static String getObfuscatedFieldName(String fieldName, String obfuscatedFieldName, String seargeFieldName)
 	{
-		return Obf.getObfuscatedFieldName(fieldName, obfuscatedFieldName, seargeFieldName);
+		return ObfuscationUtilities.getObfuscatedFieldName(fieldName, obfuscatedFieldName, seargeFieldName);
 	}
 	/**
@@ -223,10 +225,12 @@ public abstract class ModUtilities
 	 * 
 	 * @param obf Field to get, returned unmodified if in debug mode
 	 * @return Obfuscated field name if present
+	 * @deprecated use ObfuscationUtilities.getObfuscatedFieldName instead
 	 */
+	@Deprecated
 	public static String getObfuscatedFieldName(Obf obf)
 	{
-		return Obf.getObfuscatedFieldName(obf);
+		return ObfuscationUtilities.getObfuscatedFieldName(obf);
 	}
 	@SuppressWarnings("unchecked")
 package com.mumfrey.liteloader.core.event;
 import java.io.Closeable;
+import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.net.URL;
@@ -17,12 +18,15 @@ import java.util.Set;
 import net.minecraft.launchwrapper.IClassTransformer;
 import net.minecraft.launchwrapper.Launch;
+import org.apache.commons.io.FileUtils;
+import org.apache.logging.log4j.core.helpers.Booleans;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.objectweb.asm.tree.*;
+import org.objectweb.asm.util.CheckClassAdapter;
 import com.mumfrey.liteloader.Priority;
 import com.mumfrey.liteloader.core.runtime.Obf;
@@ -236,7 +240,7 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 	 */
 	protected void bake()
 	{
-		HandlerListClassLoader<T> classLoader = new HandlerListClassLoader<T>(this.type, this.logicOp);
+		HandlerListClassLoader<T> classLoader = new HandlerListClassLoader<T>(this.type, this.logicOp, this.getDecorator());
 		this.bakedHandler = classLoader.newHandler(this);
 		if (classLoader instanceof Closeable)
 		{
@@ -248,6 +252,11 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 		}
 	}
+	protected IHandlerListDecorator<T> getDecorator()
+	{
+		return null;
+	}
+
 	/**
 	 * Invalidate current baked list
 	 */
@@ -569,6 +578,10 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 	{
 		private static final String HANDLER_VAR_PREFIX = "handler$";
+		public static final boolean DUMP = Booleans.parseBoolean(System.getProperty("liteloader.debug.dump"), false);
+
+		public static final boolean VALIDATE = Booleans.parseBoolean(System.getProperty("liteloader.debug.validate"), false);
+
 		/**
 		 * Unique index number, just to ensure no name clashes
 		 */
@@ -590,6 +603,11 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 		private final ReturnLogicOp logicOp;
 		/**
+		 * Bytecode decorator
+		 */
+		private final IHandlerListDecorator<T> decorator;
+		
+		/**
 		 * Size of the handler list
 		 */
 		private int size;
@@ -598,12 +616,13 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 		 * @param type
 		 * @param logicOp
 		 */
-		HandlerListClassLoader(Class<T> type, ReturnLogicOp logicOp)
+		HandlerListClassLoader(Class<T> type, ReturnLogicOp logicOp, IHandlerListDecorator<T> decorator)
 		{
 			super(new URL[0], Launch.classLoader);
 			this.type = type;
 			this.typeRef = type.getName().replace('.', '/');
 			this.logicOp = logicOp;
+			this.decorator = decorator;
 		}
 		/**
@@ -613,6 +632,12 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 		public BakedHandlerList<T> newHandler(HandlerList<T> list)
 		{
 			this.size = list.size();
+			List<T> sortedList = list.getSortedList();
+			
+			if (this.decorator != null)
+			{
+				this.decorator.prepare(sortedList);
+			}
 			Class<BakedHandlerList<T>> handlerClass = null;
@@ -631,7 +656,7 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 			{
 				// Create an instance of the class, populate the entries from the supplied list and return it
 				BakedHandlerList<T> handlerList = this.createInstance(handlerClass);
-				return handlerList.populate(list.getSortedList());
+				return handlerList.populate(sortedList);
 			}
 			catch (InstantiationException ex)
 			{
@@ -650,6 +675,11 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 		{
 			try
 			{
+				if (this.decorator != null)
+				{
+					return this.decorator.createInstance(handlerClass);
+				}
+				
 				Constructor<BakedHandlerList<T>> ctor = handlerClass.getDeclaredConstructor();
 				ctor.setAccessible(true);
 				return ctor.newInstance();
@@ -671,7 +701,7 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 			try
 			{
 				// Read the basic class template
-				byte[] bytes = Launch.classLoader.getClassBytes(Obf.BakedHandlerList.name);
+				byte[] bytes = Launch.classLoader.getClassBytes(this.getTemplate().name);
 				ClassReader classReader = new ClassReader(bytes);
 				ClassNode classNode = new ClassNode();
 				classReader.accept(classNode, ClassReader.EXPAND_FRAMES);
@@ -683,8 +713,16 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 				ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
 				classNode.accept(classWriter);
 				bytes = classWriter.toByteArray();
+
+				if (HandlerListClassLoader.VALIDATE)
+				{
+					classNode.accept(new CheckClassAdapter(new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES)));
+				}
-//				classNode.accept(new org.objectweb.asm.util.CheckClassAdapter(new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES)));
+				if (HandlerListClassLoader.DUMP)
+				{
+					FileUtils.writeByteArrayToFile(new File(".classes/" + name.replace('.', '/') + ".class"), bytes);
+				}
 				// Delegate to ClassLoader's usual behaviour to load the class we just generated
 				return this.defineClass(name, bytes, 0, bytes.length);
@@ -696,6 +734,16 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 			}
 		}
+		private Obf getTemplate()
+		{
+			if (this.decorator != null)
+			{
+				return this.decorator.getTemplate();
+			}
+			
+			return Obf.BakedHandlerList;
+		}
+
 		/**
 		 * Perform all class bytecode transformations
 		 * 
@@ -725,7 +773,7 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 		{
 			classNode.access = classNode.access & ~Opcodes.ACC_ABSTRACT;
 			classNode.name = name.replace('.', '/');
-			classNode.superName = Obf.BakedHandlerList.ref;
+			classNode.superName = this.getTemplate().ref;
 			classNode.interfaces.add(this.typeRef);
 			classNode.sourceFile = name.substring(name.lastIndexOf('.') + 1) + ".java";
@@ -733,6 +781,11 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 			{
 				classNode.fields.add(new FieldNode(Opcodes.ACC_PRIVATE, HandlerListClassLoader.HANDLER_VAR_PREFIX + handlerIndex, "L" + this.typeRef + ";", null, null));
 			}
+			
+			if (this.decorator != null)
+			{
+				this.decorator.populateClass(name, classNode);
+			}
 		}
 		/**
@@ -775,12 +828,17 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 				if (insn instanceof MethodInsnNode)
 				{
 					MethodInsnNode methodInsn = (MethodInsnNode)insn;
-					if (methodInsn.owner.equals("java/lang/Object"))
+					if (methodInsn.getOpcode() == Opcodes.INVOKESPECIAL && methodInsn.name.equals(Obf.constructor.name))
 					{
-						methodInsn.owner = Obf.BakedHandlerList.ref;
+						methodInsn.owner = this.getTemplate().ref;
 					}
 				}
 			}
+			
+			if (this.decorator != null)
+			{
+				this.decorator.processCtor(classNode, method);
+			}
 		}
 		/**
@@ -879,6 +937,11 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 				method.access = Opcodes.ACC_PUBLIC;
 				this.populateVoidInvokationChain(classNode, method, args, returnType);
 			}
+			
+			if (this.decorator != null)
+			{
+				this.decorator.populateInterfaceMethod(classNode, method);
+			}
 		}
 		/**
@@ -963,14 +1026,25 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 		 * @param method
 		 * @param args
 		 */
-		private int invokeHandler(int handlerIndex, ClassNode classNode, MethodNode method, Type[] args)
+		private void invokeHandler(int handlerIndex, ClassNode classNode, MethodNode method, Type[] args)
 		{
 			LabelNode lineNumberLabel = new LabelNode(new Label());
 			method.instructions.add(lineNumberLabel);
 			method.instructions.add(new LineNumberNode(100 + handlerIndex, lineNumberLabel));
 			method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
 			method.instructions.add(new FieldInsnNode(Opcodes.GETFIELD, classNode.name, HandlerListClassLoader.HANDLER_VAR_PREFIX + handlerIndex, "L" + this.typeRef + ";"));
-			return this.invokeInterfaceMethod(method, args);
+			
+			if (this.decorator != null)
+			{
+				this.decorator.preInvokeInterfaceMethod(handlerIndex, classNode, method, args);
+			}
+
+			this.invokeInterfaceMethod(method, args);
+
+			if (this.decorator != null)
+			{
+				this.decorator.postInvokeInterfaceMethod(handlerIndex, classNode, method, args);
+			}
 		}
 		/**
@@ -979,7 +1053,7 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 		 * @param method
 		 * @param args
 		 */
-		private int invokeInterfaceMethod(MethodNode method, Type[] args)
+		private void invokeInterfaceMethod(MethodNode method, Type[] args)
 		{
 			int argNumber = 1;
 			for (Type type : args)
@@ -989,7 +1063,6 @@ public class HandlerList&lt;T&gt; extends LinkedList&lt;T&gt; implements FastIterableDeque&lt;T
 			}
 			method.instructions.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, this.typeRef, method.name, method.desc, true));
-			return argNumber;
 		}
 		/**
+package com.mumfrey.liteloader.core.event;
+
+import java.util.List;
+
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import com.mumfrey.liteloader.core.event.HandlerList.BakedHandlerList;
+import com.mumfrey.liteloader.core.runtime.Obf;
+
+/**
+ * Essentially a "mini plugin" for HandlerListClassLoader which allows alterations of the generated bytecode
+ * 
+ * @author Adam Mummery-Smith
+ *
+ * @param <T>
+ */
+public interface IHandlerListDecorator<T>
+{
+	/**
+	 * Get the template class name
+	 */
+	public abstract Obf getTemplate();
+	
+	/**
+	 * Prepare the decorator to accept the specified list of invokees
+	 */
+	public abstract void prepare(List<T> sortedList);
+	
+	/**
+	 * Create an instance of the handler class
+	 */
+	public abstract BakedHandlerList<T> createInstance(Class<BakedHandlerList<T>> handlerClass) throws Exception;
+
+	/**
+	 * Called when populating the classNode
+	 */
+	public abstract void populateClass(String name, ClassNode classNode);
+
+	/**
+	 * Called when processing the ctor
+	 */
+	public abstract void processCtor(ClassNode classNode, MethodNode method);
+
+	/**
+	 * Called immediately before the interface method invokation bytecode is injected
+	 */
+	public abstract void preInvokeInterfaceMethod(int handlerIndex, ClassNode classNode, MethodNode method, Type[] args);
+
+	/**
+	 * Called immediately after the interface method invokation bytecode is injected
+	 */
+	public abstract void postInvokeInterfaceMethod(int handlerIndex, ClassNode classNode, MethodNode method, Type[] args);
+	
+	/**
+	 * Called at the end of populateInterfaceMethod
+	 */
+	public abstract void populateInterfaceMethod(ClassNode classNode, MethodNode method);
+}
+package com.mumfrey.liteloader.core.event;
+
+import java.lang.reflect.Constructor;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.profiler.Profiler;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.InsnNode;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+import com.mumfrey.liteloader.api.Listener;
+import com.mumfrey.liteloader.core.runtime.Obf;
+
+/**
+ * A HandlerList which calls Profiler.beginSection and Profiler.endSection before every invokation
+ * 
+ * @author Adam Mummery-Smith
+ *
+ * @param <T>
+ */
+public class ProfilingHandlerList<T extends Listener> extends HandlerList<T>
+{
+	private static final long serialVersionUID = 1L;
+	
+	/**
+	 * Profiler to pass in to baked handler lists
+	 */
+	private final Profiler profiler;
+
+	/**
+	 * @param type
+	 * @param profiler
+	 */
+	public ProfilingHandlerList(Class<T> type, Profiler profiler)
+	{
+		super(type);
+		this.profiler = profiler;
+	}
+	
+	/**
+	 * @param type
+	 * @param logicOp
+	 * @param profiler
+	 */
+	public ProfilingHandlerList(Class<T> type, ReturnLogicOp logicOp, Profiler profiler)
+	{
+		super(type, logicOp);
+		this.profiler = profiler;
+	}
+	
+	/**
+	 * @param type
+	 * @param logicOp
+	 * @param sorted
+	 * @param profiler
+	 */
+	public ProfilingHandlerList(Class<T> type, ReturnLogicOp logicOp, boolean sorted, Profiler profiler)
+	{
+		super(type, logicOp, sorted);
+		this.profiler = profiler;
+	}
+	
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.core.event.HandlerList#getDecorator()
+	 */
+	@Override
+	protected IHandlerListDecorator<T> getDecorator()
+	{
+		return new ProfilingHandlerListDecorator<T>(this.profiler);
+	}
+	
+	/**
+	 * Decorator which adds the profiler section calls to the invokation lists
+	 */
+	static class ProfilingHandlerListDecorator<T extends Listener> implements IHandlerListDecorator<T>
+	{
+		private final Profiler profiler;
+		
+		private final List<String> names = new ArrayList<String>();;
+		
+		protected ProfilingHandlerListDecorator(Profiler profiler)
+		{
+			this.profiler = profiler;
+		}
+
+		/* (non-Javadoc)
+		 * @see com.mumfrey.liteloader.core.event.IHandlerListDecorator#getTemplate()
+		 */
+		@Override
+		public Obf getTemplate()
+		{
+			return Obf.BakedProfilingHandlerList;
+		}
+		
+		/* (non-Javadoc)
+		 * @see com.mumfrey.liteloader.core.event.IHandlerListDecorator#prepare(java.util.List)
+		 */
+		@Override
+		public void prepare(List<T> sortedList)
+		{
+			this.names.clear();
+			
+			for (Listener l : sortedList)
+			{
+				String name = l.getName();
+				this.names.add(name != null ? name : l.getClass().getSimpleName());
+			}
+		}
+
+		/* (non-Javadoc)
+		 * @see com.mumfrey.liteloader.core.event.IHandlerListDecorator#createInstance(java.lang.Class)
+		 */
+		@Override
+		public BakedHandlerList<T> createInstance(Class<BakedHandlerList<T>> handlerClass) throws Exception
+		{
+			try
+			{
+				Constructor<BakedHandlerList<T>> ctor = handlerClass.getDeclaredConstructor(Profiler.class);
+				ctor.setAccessible(true);
+				return ctor.newInstance(this.profiler);
+			}
+			catch (Exception ex)
+			{
+				ex.printStackTrace();
+				throw ex;
+			}
+		}
+
+		/* (non-Javadoc)
+		 * @see com.mumfrey.liteloader.core.event.IHandlerListDecorator#populateClass(java.lang.String, org.objectweb.asm.tree.ClassNode)
+		 */
+		@Override
+		public void populateClass(String name, ClassNode classNode)
+		{
+		}
+
+		/* (non-Javadoc)
+		 * @see com.mumfrey.liteloader.core.event.IHandlerListDecorator#processCtor(org.objectweb.asm.tree.ClassNode, org.objectweb.asm.tree.MethodNode)
+		 */
+		@Override
+		public void processCtor(ClassNode classNode, MethodNode method)
+		{
+			// Actually replace the ctor code because it's easier
+			method.instructions.clear();
+			method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
+			method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 1));
+			method.instructions.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, Obf.BakedProfilingHandlerList.ref, Obf.constructor.name, method.desc, false));
+			method.instructions.add(new InsnNode(Opcodes.RETURN));
+		}
+		
+		/* (non-Javadoc)
+		 * @see com.mumfrey.liteloader.core.event.IHandlerListDecorator#preInvokeInterfaceMethod(int, org.objectweb.asm.tree.ClassNode, org.objectweb.asm.tree.MethodNode, org.objectweb.asm.Type[])
+		 */
+		@Override
+		public void preInvokeInterfaceMethod(int handlerIndex, ClassNode classNode, MethodNode method, Type[] args)
+		{
+			// Call this.startSection
+			method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
+			method.instructions.add(new LdcInsnNode(this.names.get(handlerIndex)));
+			method.instructions.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, classNode.superName, "startSection", "(Ljava/lang/String;)V", false));
+		}
+
+		/* (non-Javadoc)
+		 * @see com.mumfrey.liteloader.core.event.IHandlerListDecorator#postInvokeInterfaceMethod(int, org.objectweb.asm.tree.ClassNode, org.objectweb.asm.tree.MethodNode, org.objectweb.asm.Type[])
+		 */
+		@Override
+		public void postInvokeInterfaceMethod(int handlerIndex, ClassNode classNode, MethodNode method, Type[] args)
+		{
+			// Call this.endSection
+			method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
+			method.instructions.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, classNode.superName, "endSection", "()V", false));
+		}
+
+		/* (non-Javadoc)
+		 * @see com.mumfrey.liteloader.core.event.IHandlerListDecorator#populateInterfaceMethod(org.objectweb.asm.tree.ClassNode, org.objectweb.asm.tree.MethodNode)
+		 */
+		@Override
+		public void populateInterfaceMethod(ClassNode classNode, MethodNode method)
+		{
+		}
+	}
+	
+	/**
+	 * Template class for the profiling handler lists
+	 * 
+	 * @author Adam Mummery-Smith
+	 *
+	 * @param <T>
+	 */
+	public static abstract class BakedList<T> extends HandlerList.BakedHandlerList<T>
+	{
+		private final Profiler profiler;
+		
+		public BakedList(Profiler profiler)
+		{
+			this.profiler = profiler;
+		}
+
+		@Override
+		public abstract T get();
+
+		@Override
+		public abstract BakedHandlerList<T> populate(List<T> listeners);
+		
+		protected void startSection(String name)
+		{
+			this.profiler.startSection(name);
+		}
+		
+		protected void endSection()
+		{
+			this.profiler.endSection();
+		}
+	}
+}
@@ -7,10 +7,6 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
-import net.minecraft.launchwrapper.IClassTransformer;
-import net.minecraft.launchwrapper.Launch;
-import net.minecraft.server.MinecraftServer;
-
 /**
  * Centralised obfuscation table for LiteLoader
  *
@@ -26,6 +22,7 @@ public class Obf
 	public static final Obf                   EventProxy = new Obf("com.mumfrey.liteloader.core.event.EventProxy"                      );
 	public static final Obf                  HandlerList = new Obf("com.mumfrey.liteloader.core.event.HandlerList"                     );
 	public static final Obf             BakedHandlerList = new Obf("com.mumfrey.liteloader.core.event.HandlerList$BakedHandlerList"    );
+	public static final Obf    BakedProfilingHandlerList = new Obf("com.mumfrey.liteloader.core.event.ProfilingHandlerList$BakedList"  );
 	public static final Obf                 PacketEvents = new Obf("com.mumfrey.liteloader.core.PacketEvents"                          );
 	public static final Obf           PacketEventsClient = new Obf("com.mumfrey.liteloader.client.PacketEventsClient"                  );
 	public static final Obf                   LoadingBar = new Obf("com.mumfrey.liteloader.client.gui.startup.LoadingBar"              );
@@ -106,6 +103,7 @@ public class Obf
 	public static final Obf                  shaderIndex = new Obf("field_147713_ae",                                            "ac"  );
 	public static final Obf                    useShader = new Obf("field_175083_ad",                                            "ad"  );
 	public static final Obf                 viewDistance = new Obf("field_149528_b",                                             "b"   );
+	public static final Obf                   entityPosY = new Obf("field_70163_u",                                              "t"   );
 	// Methods
 	// -----------------------------------------------------------------------------------------
@@ -152,6 +150,7 @@ public class Obf
 	public static final Obf         processPlayerDigging = new Obf("func_147345_a",                                              "a"   );
 	public static final Obf   updateTimeLightAndEntities = new Obf("func_71190_q",                                               "z"   );
 	public static final Obf        checkThreadAndEnqueue = new Obf("func_180031_a",                                              "a"   );
+	public static final Obf                processPlayer = new Obf("func_147347_a",                                              "a"   );
 	public static final int MCP = 0;
 	public static final int SRG = 1;
@@ -353,6 +352,17 @@ public class Obf
 		return Obf.getByName(name);
 	}
+	public static String lookupMCPName(String obfName)
+	{
+		for (Obf obf : Obf.obfs.values())
+		{
+			if (obfName.equals(obf.obf))
+				return obf.name;
+		}
+		
+		return obfName;
+	}
+	
 	/**
 	 * Ordinal reference, can be passed to some methods which accept an {@link Obf} to indicate an offset into a
 	 * class rather than a named reference.
@@ -403,61 +413,4 @@ public class Obf
 			return this.ordinal;
 		}
 	}
-
-	/**
-	 * True if FML is being used, in which case we use searge names instead of raw field/method names
-	 */
-	private static boolean fmlDetected = false;
-	
-	private static boolean seargeNames = false;
-	
-	static
-	{
-		// Check for FML
-		Obf.fmlDetected = Obf.fmlIsPresent();
-
-		try
-		{
-			MinecraftServer.class.getDeclaredField("serverRunning");
-		}
-		catch (SecurityException ex)
-		{
-		}
-		catch (NoSuchFieldException ex)
-		{
-			Obf.seargeNames = true;
-		}
-	}
-
-	public static boolean fmlIsPresent()
-	{
-		for (IClassTransformer transformer : Launch.classLoader.getTransformers())
-			if (transformer.getClass().getName().contains("fml")) return true;
-
-		return false;
-	}
-
-	/**
-	 * Abstraction helper function
-	 * 
-	 * @param fieldName Name of field to get, returned unmodified if in debug mode
-	 * @return Obfuscated field name if present
-	 */
-	public static String getObfuscatedFieldName(String fieldName, String obfuscatedFieldName, String seargeFieldName)
-	{
-		boolean deobfuscated = MinecraftServer.class.getSimpleName().equals("MinecraftServer");
-		return deobfuscated ? (Obf.seargeNames ? seargeFieldName : fieldName) : (Obf.fmlDetected ? seargeFieldName : obfuscatedFieldName);
-	}
-	
-	/**
-	 * Abstraction helper function
-	 * 
-	 * @param obf Field to get, returned unmodified if in debug mode
-	 * @return Obfuscated field name if present
-	 */
-	public static String getObfuscatedFieldName(Obf obf)
-	{
-		boolean deobfuscated = MinecraftServer.class.getSimpleName().equals("MinecraftServer");
-		return deobfuscated ? (Obf.seargeNames ? obf.srg : obf.name) : (Obf.fmlDetected ? obf.srg : obf.obf);
-	}
 }
@@ -344,8 +344,24 @@ public abstract class ByteCodeUtilities
 	 */
 	public static List<LocalVariableNode> generateLocalVariableTable(ClassNode classNode, MethodNode method)
 	{
+		List<Type> interfaces = null;
+		if (classNode.interfaces != null)
+		{
+			interfaces = new ArrayList<Type>();
+			for (String iface : classNode.interfaces)
+			{
+				interfaces.add(Type.getObjectType(iface));
+			}
+		}
+		
+		Type objectType = null;
+		if (classNode.superName != null)
+		{
+			objectType = Type.getObjectType(classNode.superName);
+		}
+		
 		// Use Analyzer to generate the bytecode frames
-		Analyzer<BasicValue> analyzer = new Analyzer<BasicValue>(new SimpleVerifier(Type.getObjectType(classNode.name), null, null, false));
+		Analyzer<BasicValue> analyzer = new Analyzer<BasicValue>(new SimpleVerifier(Type.getObjectType(classNode.name), objectType, interfaces, false));
 		try
 		{
 			analyzer.analyze(classNode.name, method);
+package com.mumfrey.liteloader.util;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+import net.minecraft.launchwrapper.Launch;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.BlockPos;
+
+import com.mumfrey.liteloader.core.runtime.Obf;
+
+public class ObfuscationUtilities
+{
+	/**
+	 * True if FML is being used, in which case we use searge names instead of raw field/method names
+	 */
+	private static boolean fmlDetected = false;
+	
+	private static boolean seargeNames = false;
+	
+	static
+	{
+		// Check for FML
+		ObfuscationUtilities.fmlDetected = ObfuscationUtilities.fmlIsPresent();
+
+		try
+		{
+			MinecraftServer.class.getDeclaredField("serverRunning");
+		}
+		catch (SecurityException ex)
+		{
+		}
+		catch (NoSuchFieldException ex)
+		{
+			ObfuscationUtilities.seargeNames = true;
+		}
+	}
+
+	public static boolean fmlIsPresent()
+	{
+		for (IClassTransformer transformer : Launch.classLoader.getTransformers())
+			if (transformer.getClass().getName().contains("fml")) return true;
+
+		return false;
+	}
+
+	/**
+	 * Abstraction helper function
+	 * 
+	 * @param fieldName Name of field to get, returned unmodified if in debug mode
+	 * @return Obfuscated field name if present
+	 */
+	public static String getObfuscatedFieldName(String fieldName, String obfuscatedFieldName, String seargeFieldName)
+	{
+		boolean deobfuscated = BlockPos.class.getSimpleName().equals("BlockPos");
+		return deobfuscated ? (ObfuscationUtilities.seargeNames ? seargeFieldName : fieldName) : (ObfuscationUtilities.fmlDetected ? seargeFieldName : obfuscatedFieldName);
+	}
+	
+	/**
+	 * Abstraction helper function
+	 * 
+	 * @param obf Field to get, returned unmodified if in debug mode
+	 * @return Obfuscated field name if present
+	 */
+	public static String getObfuscatedFieldName(Obf obf)
+	{
+		boolean deobfuscated = BlockPos.class.getSimpleName().equals("BlockPos");
+		return deobfuscated ? (ObfuscationUtilities.seargeNames ? obf.srg : obf.name) : (ObfuscationUtilities.fmlDetected ? obf.srg : obf.obf);
+	}
+}