From 29f274c5d1acec1130683cbdd77daf309a21f909 Mon Sep 17 00:00:00 2001
From: Marek Safar <marek.safar@gmail.com>
Date: Tue, 20 Nov 2012 17:48:01 +0100
Subject: [PATCH] Update to the latest IKVM.Reflection

---
 mcs/class/IKVM.Reflection/Assembly.cs         |  67 +++-
 mcs/class/IKVM.Reflection/AssemblyName.cs     |  75 +++-
 .../IKVM.Reflection/CustomAttributeData.cs    |   8 +-
 .../CustomAttributeNamedArgument.cs           |  10 +
 mcs/class/IKVM.Reflection/CustomModifiers.cs  |   2 +-
 .../IKVM.Reflection/Emit/AssemblyBuilder.cs   |  23 +-
 .../Emit/ConstructorBuilder.cs                |   6 +
 .../Emit/CustomAttributeBuilder.cs            |   2 +-
 mcs/class/IKVM.Reflection/Emit/EnumBuilder.cs |   5 +
 .../IKVM.Reflection/Emit/EventBuilder.cs      |   2 +-
 .../IKVM.Reflection/Emit/ExceptionHandler.cs  | 121 +++++++
 mcs/class/IKVM.Reflection/Emit/ILGenerator.cs | 341 ++++++++----------
 .../IKVM.Reflection/Emit/MethodBuilder.cs     |  52 +++
 .../IKVM.Reflection/Emit/ModuleBuilder.cs     |   7 +-
 .../IKVM.Reflection/Emit/PropertyBuilder.cs   |   2 +-
 .../IKVM.Reflection/Emit/SignatureHelper.cs   |   4 +-
 mcs/class/IKVM.Reflection/Emit/Tokens.cs      |  10 -
 mcs/class/IKVM.Reflection/Emit/TypeBuilder.cs |  16 +-
 mcs/class/IKVM.Reflection/Enums.cs            |   3 +-
 mcs/class/IKVM.Reflection/EventInfo.cs        |  15 +
 mcs/class/IKVM.Reflection/Fusion.cs           |   9 +-
 .../IKVM.Reflection/IKVM.Reflection.csproj    |   4 +
 .../IKVM.Reflection/LocalVariableInfo.cs      |  14 +-
 mcs/class/IKVM.Reflection/MarshalSpec.cs      |  58 +--
 mcs/class/IKVM.Reflection/MemberInfo.cs       |  10 +
 .../IKVM.Reflection/Metadata/CliHeader.cs     |  33 +-
 mcs/class/IKVM.Reflection/Metadata/Tables.cs  |   6 +-
 mcs/class/IKVM.Reflection/MethodBase.cs       |   5 +
 mcs/class/IKVM.Reflection/MethodSignature.cs  |  10 +-
 mcs/class/IKVM.Reflection/Missing.cs          |  14 +-
 mcs/class/IKVM.Reflection/Module.cs           |  15 +
 mcs/class/IKVM.Reflection/ParameterInfo.cs    |  15 +
 mcs/class/IKVM.Reflection/PropertyInfo.cs     |  10 +
 .../IKVM.Reflection/PropertySignature.cs      |   4 +-
 .../IKVM.Reflection/Reader/AssemblyReader.cs  |  67 +++-
 .../IKVM.Reflection/Reader/Authenticode.cs    |  15 +
 .../IKVM.Reflection/Reader/ByteReader.cs      |  29 +-
 .../IKVM.Reflection/Reader/ModuleReader.cs    |  54 +--
 mcs/class/IKVM.Reflection/Reader/PEReader.cs  |   6 -
 mcs/class/IKVM.Reflection/Signature.cs        |  51 ++-
 mcs/class/IKVM.Reflection/Type.cs             |  97 ++++-
 mcs/class/IKVM.Reflection/Universe.cs         |  18 +
 .../IKVM.Reflection/Writer/ByteBuffer.cs      |  39 +-
 mcs/class/IKVM.Reflection/Writer/Heaps.cs     |   8 +-
 .../IKVM.Reflection/Writer/MetadataWriter.cs  |   4 +-
 .../IKVM.Reflection/Writer/ModuleWriter.cs    |   2 +-
 mcs/class/IKVM.Reflection/reflect.build       |   3 +
 mcs/mcs/method.cs                             |   4 +-
 48 files changed, 989 insertions(+), 386 deletions(-)
 create mode 100644 mcs/class/IKVM.Reflection/Emit/ExceptionHandler.cs
 create mode 100644 mcs/class/IKVM.Reflection/Reader/Authenticode.cs

diff --git a/mcs/class/IKVM.Reflection/Assembly.cs b/mcs/class/IKVM.Reflection/Assembly.cs
index 715e774bdeb..5f3a5fa8674 100644
--- a/mcs/class/IKVM.Reflection/Assembly.cs
+++ b/mcs/class/IKVM.Reflection/Assembly.cs
@@ -26,10 +26,13 @@ using System.Collections.Generic;
 
 namespace IKVM.Reflection
 {
+	public delegate Module ModuleResolveEventHandler(object sender, ResolveEventArgs e);
+
 	public abstract class Assembly : ICustomAttributeProvider
 	{
 		internal readonly Universe universe;
 		protected string fullName;	// AssemblyBuilder needs access to this field to clear it when the name changes
+		protected List<ModuleResolveEventHandler> resolvers;
 
 		internal Assembly(Universe universe)
 		{
@@ -41,6 +44,22 @@ namespace IKVM.Reflection
 			return FullName;
 		}
 
+		public event ModuleResolveEventHandler ModuleResolve
+		{
+			add
+			{
+				if (resolvers == null)
+				{
+					resolvers = new List<ModuleResolveEventHandler>();
+				}
+				resolvers.Add(value);
+			}
+			remove
+			{
+				resolvers.Remove(value);
+			}
+		}
+
 		public abstract Type[] GetTypes();
 		public abstract AssemblyName GetName();
 		public abstract string ImageRuntimeVersion { get; }
@@ -76,6 +95,11 @@ namespace IKVM.Reflection
 			return GetModules(true);
 		}
 
+		public IEnumerable<Module> Modules
+		{
+			get { return GetLoadedModules(); }
+		}
+
 		public Module[] GetLoadedModules()
 		{
 			return GetLoadedModules(true);
@@ -104,6 +128,25 @@ namespace IKVM.Reflection
 			return list.ToArray();
 		}
 
+		public IEnumerable<Type> ExportedTypes
+		{
+			get { return GetExportedTypes(); }
+		}
+
+		public IEnumerable<TypeInfo> DefinedTypes
+		{
+			get
+			{
+				Type[] types = GetTypes();
+				TypeInfo[] typeInfos = new TypeInfo[types.Length];
+				for (int i = 0; i < types.Length; i++)
+				{
+					typeInfos[i] = types[i].GetTypeInfo();
+				}
+				return typeInfos;
+			}
+		}
+
 		public Type GetType(string name)
 		{
 			return GetType(name, false);
@@ -163,6 +206,16 @@ namespace IKVM.Reflection
 			return CustomAttributeData.__GetCustomAttributes(this, attributeType, inherit);
 		}
 
+		public IList<CustomAttributeData> GetCustomAttributesData()
+		{
+			return CustomAttributeData.GetCustomAttributes(this);
+		}
+
+		public IEnumerable<CustomAttributeData> CustomAttributes
+		{
+			get { return GetCustomAttributesData(); }
+		}
+
 		public static string CreateQualifiedName(string assemblyName, string typeName)
 		{
 			return typeName + ", " + assemblyName;
@@ -186,14 +239,24 @@ namespace IKVM.Reflection
 			}
 		}
 
+		public virtual bool IsDynamic
+		{
+			get { return false; }
+		}
+
 		public virtual bool __IsMissing
 		{
 			get { return false; }
 		}
 
-		public virtual AssemblyNameFlags __AssemblyFlags
+		public AssemblyNameFlags __AssemblyFlags
+		{
+			get { return GetAssemblyFlags(); }
+		}
+
+		protected virtual AssemblyNameFlags GetAssemblyFlags()
 		{
-			get { return GetName().Flags; }
+			return GetName().Flags;
 		}
 
 		internal abstract IList<CustomAttributeData> GetCustomAttributesData(Type attributeType);
diff --git a/mcs/class/IKVM.Reflection/AssemblyName.cs b/mcs/class/IKVM.Reflection/AssemblyName.cs
index 0812194b844..beae6ad0cb8 100644
--- a/mcs/class/IKVM.Reflection/AssemblyName.cs
+++ b/mcs/class/IKVM.Reflection/AssemblyName.cs
@@ -25,6 +25,7 @@ using System;
 using System.Globalization;
 using System.Configuration.Assemblies;
 using System.IO;
+using System.Security.Cryptography;
 using System.Text;
 using IKVM.Reflection.Reader;
 
@@ -41,6 +42,7 @@ namespace IKVM.Reflection
 		private AssemblyNameFlags flags;
 		private AssemblyHashAlgorithm hashAlgorithm;
 		private AssemblyVersionCompatibility versionCompatibility = AssemblyVersionCompatibility.SameMachine;
+		private ProcessorArchitecture processorArchitecture;
 		private string codeBase;
 		internal byte[] hash;
 
@@ -62,9 +64,8 @@ namespace IKVM.Reflection
 			switch (Fusion.ParseAssemblyName(assemblyName, out parsed))
 			{
 				case ParseAssemblyResult.GenericError:
-					throw new FileLoadException();
 				case ParseAssemblyResult.DuplicateKey:
-					throw new System.Runtime.InteropServices.COMException();
+					throw new FileLoadException();
 			}
 			name = parsed.Name;
 			if (parsed.Culture != null)
@@ -99,12 +100,7 @@ namespace IKVM.Reflection
 				}
 				else
 				{
-					publicKeyToken = new byte[8];
-					for (int i = 0, pos = 0; i < publicKeyToken.Length; i++, pos += 2)
-					{
-						publicKeyToken[i] = (byte)("0123456789abcdef".IndexOf(char.ToLowerInvariant(parsed.PublicKeyToken[pos])) * 16
-							+ "0123456789abcdef".IndexOf(char.ToLowerInvariant(parsed.PublicKeyToken[pos + 1])));
-					}
+					publicKeyToken = ParseKey(parsed.PublicKeyToken);
 				}
 			}
 			if (parsed.Retargetable.HasValue)
@@ -125,6 +121,40 @@ namespace IKVM.Reflection
 			}
 		}
 
+		private static byte[] ParseKey(string key)
+		{
+			if ((key.Length & 1) != 0)
+			{
+				throw new FileLoadException();
+			}
+			byte[] buf = new byte[key.Length / 2];
+			for (int i = 0; i < buf.Length; i++)
+			{
+				buf[i] = (byte)(ParseHexDigit(key[i * 2]) * 16 + ParseHexDigit(key[i * 2 + 1]));
+			}
+			return buf;
+		}
+
+		private static int ParseHexDigit(char digit)
+		{
+			if (digit >= '0' && digit <= '9')
+			{
+				return digit - '0';
+			}
+			else
+			{
+				digit |= (char)0x20;
+				if (digit >= 'a' && digit <= 'f')
+				{
+					return 10 + digit - 'a';
+				}
+				else
+				{
+					throw new FileLoadException();
+				}
+			}
+		}
+
 		public override string ToString()
 		{
 			return FullName;
@@ -142,6 +172,11 @@ namespace IKVM.Reflection
 			set { culture = value == null ? null : value.Name; }
 		}
 
+		public string CultureName
+		{
+			get { return culture; }
+		}
+
 		internal string Culture
 		{
 			get { return culture; }
@@ -179,11 +214,12 @@ namespace IKVM.Reflection
 
 		public ProcessorArchitecture ProcessorArchitecture
 		{
-			get { return (ProcessorArchitecture)(((int)flags & 0x70) >> 4); }
+			get { return processorArchitecture; }
 			set
 			{
 				if (value >= ProcessorArchitecture.None && value <= ProcessorArchitecture.Arm)
 				{
+					processorArchitecture = value;
 					flags = (flags & ~(AssemblyNameFlags)0x70) | (AssemblyNameFlags)((int)value << 4);
 				}
 			}
@@ -351,17 +387,20 @@ namespace IKVM.Reflection
 			{
 				return publicKey;
 			}
-			// HACK use the real AssemblyName to convert PublicKey to PublicKeyToken
-			StringBuilder sb = new StringBuilder("Foo, PublicKey=", 20 + publicKey.Length * 2);
-			AppendPublicKey(sb, publicKey);
-			string str = sb.ToString();
-			if (str == "Foo, PublicKey=00000000000000000400000000000000")
+			byte[] hash = new SHA1Managed().ComputeHash(publicKey);
+			byte[] token = new byte[8];
+			for (int i = 0; i < token.Length; i++)
 			{
-				// MONOBUG workaround Mono 2.10 bug (fixed in 2.11)
-				// it does not return the correct public key token for the ECMA key
-				return new byte[] { 0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89 };
+				token[i] = hash[hash.Length - 1 - i];
 			}
-			return new System.Reflection.AssemblyName(str).GetPublicKeyToken();
+			return token;
+		}
+
+		internal static string ComputePublicKeyToken(string publicKey)
+		{
+			StringBuilder sb = new StringBuilder(16);
+			AppendPublicKey(sb, ComputePublicKeyToken(ParseKey(publicKey)));
+			return sb.ToString();
 		}
 
 		private static void AppendPublicKey(StringBuilder sb, byte[] publicKey)
diff --git a/mcs/class/IKVM.Reflection/CustomAttributeData.cs b/mcs/class/IKVM.Reflection/CustomAttributeData.cs
index 72026fb9b4d..6c4c2a7b641 100644
--- a/mcs/class/IKVM.Reflection/CustomAttributeData.cs
+++ b/mcs/class/IKVM.Reflection/CustomAttributeData.cs
@@ -243,13 +243,13 @@ namespace IKVM.Reflection
 			if (br.PeekByte() == '.')
 			{
 				br.ReadByte();
-				int count = br.ReadCompressedInt();
+				int count = br.ReadCompressedUInt();
 				for (int j = 0; j < count; j++)
 				{
 					Type type = ReadType(asm, br);
 					ConstructorInfo constructor = type.GetPseudoCustomAttributeConstructor(u.System_Security_Permissions_SecurityAction);
 					// LAMESPEC there is an additional length here (probably of the named argument list)
-					byte[] blob = br.ReadBytes(br.ReadCompressedInt());
+					byte[] blob = br.ReadBytes(br.ReadCompressedUInt());
 					list.Add(new CustomAttributeData(asm, constructor, action, blob, index));
 				}
 			}
@@ -601,7 +601,7 @@ namespace IKVM.Reflection
 						// 5) Unresolved declarative security
 						ByteReader br = new ByteReader(declSecurityBlob, 0, declSecurityBlob.Length);
 						// LAMESPEC the count of named arguments is a compressed integer (instead of UInt16 as NumNamed in custom attributes)
-						lazyNamedArguments = ReadNamedArguments(module.Assembly, br, br.ReadCompressedInt(), Constructor.DeclaringType);
+						lazyNamedArguments = ReadNamedArguments(module.Assembly, br, br.ReadCompressedUInt(), Constructor.DeclaringType);
 					}
 				}
 				return lazyNamedArguments;
@@ -736,7 +736,7 @@ namespace IKVM.Reflection
 			}
 			ModuleBuilder mb = module as ModuleBuilder;
 			int token = parameter.MetadataToken;
-			if (mb != null && mb.IsSaved && mb.IsPseudoToken(token))
+			if (mb != null && mb.IsSaved && ModuleBuilder.IsPseudoToken(token))
 			{
 				token = mb.ResolvePseudoToken(token);
 			}
diff --git a/mcs/class/IKVM.Reflection/CustomAttributeNamedArgument.cs b/mcs/class/IKVM.Reflection/CustomAttributeNamedArgument.cs
index d9a84b7a74a..4b4a8ea8c80 100644
--- a/mcs/class/IKVM.Reflection/CustomAttributeNamedArgument.cs
+++ b/mcs/class/IKVM.Reflection/CustomAttributeNamedArgument.cs
@@ -58,6 +58,16 @@ namespace IKVM.Reflection
 			get { return value; }
 		}
 
+		public bool IsField
+		{
+			get { return member.MemberType == MemberTypes.Field; }
+		}
+
+		public string MemberName
+		{
+			get { return member.Name; }
+		}
+
 		public static bool operator ==(CustomAttributeNamedArgument arg1, CustomAttributeNamedArgument arg2)
 		{
 			return arg1.member.Equals(arg2.member) && arg1.value == arg2.value;
diff --git a/mcs/class/IKVM.Reflection/CustomModifiers.cs b/mcs/class/IKVM.Reflection/CustomModifiers.cs
index e8670614e96..dade700ac14 100644
--- a/mcs/class/IKVM.Reflection/CustomModifiers.cs
+++ b/mcs/class/IKVM.Reflection/CustomModifiers.cs
@@ -293,7 +293,7 @@ namespace IKVM.Reflection
 			while (IsCustomModifier(b))
 			{
 				br.ReadByte();
-				br.ReadCompressedInt();
+				br.ReadCompressedUInt();
 				b = br.PeekByte();
 			}
 		}
diff --git a/mcs/class/IKVM.Reflection/Emit/AssemblyBuilder.cs b/mcs/class/IKVM.Reflection/Emit/AssemblyBuilder.cs
index ceabeac73af..910a6db8a7c 100644
--- a/mcs/class/IKVM.Reflection/Emit/AssemblyBuilder.cs
+++ b/mcs/class/IKVM.Reflection/Emit/AssemblyBuilder.cs
@@ -180,16 +180,26 @@ namespace IKVM.Reflection.Emit
 			this.hashAlgorithm = hashAlgorithm;
 		}
 
+		[Obsolete("Use __AssemblyFlags property instead.")]
 		public void __SetAssemblyFlags(AssemblyNameFlags flags)
 		{
-			AssemblyName oldName = GetName();
-			this.flags = flags;
-			Rename(oldName);
+			this.__AssemblyFlags = flags;
+		}
+
+		protected override AssemblyNameFlags GetAssemblyFlags()
+		{
+			return flags;
 		}
 
-		public override AssemblyNameFlags __AssemblyFlags
+		public new AssemblyNameFlags __AssemblyFlags
 		{
 			get { return flags; }
+			set
+			{
+				AssemblyName oldName = GetName();
+				this.flags = value;
+				Rename(oldName);
+			}
 		}
 
 		internal string Name
@@ -730,6 +740,11 @@ namespace IKVM.Reflection.Emit
 			throw new NotSupportedException();
 		}
 
+		public override bool IsDynamic
+		{
+			get { return true; }
+		}
+
 		internal override IList<CustomAttributeData> GetCustomAttributesData(Type attributeType)
 		{
 			List<CustomAttributeData> list = new List<CustomAttributeData>();
diff --git a/mcs/class/IKVM.Reflection/Emit/ConstructorBuilder.cs b/mcs/class/IKVM.Reflection/Emit/ConstructorBuilder.cs
index 308679dbb85..02ccca1fe4f 100644
--- a/mcs/class/IKVM.Reflection/Emit/ConstructorBuilder.cs
+++ b/mcs/class/IKVM.Reflection/Emit/ConstructorBuilder.cs
@@ -22,6 +22,7 @@
   
 */
 using System;
+using System.Collections.Generic;
 
 namespace IKVM.Reflection.Emit
 {
@@ -122,6 +123,11 @@ namespace IKVM.Reflection.Emit
 			set { methodBuilder.InitLocals = value; }
 		}
 
+		public void SetMethodBody(byte[] il, int maxStack, byte[] localSignature, IEnumerable<ExceptionHandler> exceptionHandlers, IEnumerable<int> tokenFixups)
+		{
+			methodBuilder.SetMethodBody(il, maxStack, localSignature, exceptionHandlers, tokenFixups);
+		}
+
 		internal override MethodInfo GetMethodInfo()
 		{
 			return methodBuilder;
diff --git a/mcs/class/IKVM.Reflection/Emit/CustomAttributeBuilder.cs b/mcs/class/IKVM.Reflection/Emit/CustomAttributeBuilder.cs
index 12be4a466d4..2b9708b5c12 100644
--- a/mcs/class/IKVM.Reflection/Emit/CustomAttributeBuilder.cs
+++ b/mcs/class/IKVM.Reflection/Emit/CustomAttributeBuilder.cs
@@ -377,7 +377,7 @@ namespace IKVM.Reflection.Emit
 
 			private void WritePackedLen(int len)
 			{
-				bb.WriteCompressedInt(len);
+				bb.WriteCompressedUInt(len);
 			}
 
 			private void WriteFieldOrPropType(Type type)
diff --git a/mcs/class/IKVM.Reflection/Emit/EnumBuilder.cs b/mcs/class/IKVM.Reflection/Emit/EnumBuilder.cs
index e93e7e736dd..eacacb01f5b 100644
--- a/mcs/class/IKVM.Reflection/Emit/EnumBuilder.cs
+++ b/mcs/class/IKVM.Reflection/Emit/EnumBuilder.cs
@@ -86,6 +86,11 @@ namespace IKVM.Reflection.Emit
 			return typeBuilder.CreateType();
 		}
 
+		public TypeInfo CreateTypeInfo()
+		{
+			return typeBuilder.CreateTypeInfo();
+		}
+
 		public TypeToken TypeToken
 		{
 			get { return typeBuilder.TypeToken; }
diff --git a/mcs/class/IKVM.Reflection/Emit/EventBuilder.cs b/mcs/class/IKVM.Reflection/Emit/EventBuilder.cs
index 6e98d3711ea..03242720cb4 100644
--- a/mcs/class/IKVM.Reflection/Emit/EventBuilder.cs
+++ b/mcs/class/IKVM.Reflection/Emit/EventBuilder.cs
@@ -268,7 +268,7 @@ namespace IKVM.Reflection.Emit
 
 		internal override int GetCurrentToken()
 		{
-			if (typeBuilder.ModuleBuilder.IsSaved && typeBuilder.ModuleBuilder.IsPseudoToken(lazyPseudoToken))
+			if (typeBuilder.ModuleBuilder.IsSaved && ModuleBuilder.IsPseudoToken(lazyPseudoToken))
 			{
 				return typeBuilder.ModuleBuilder.ResolvePseudoToken(lazyPseudoToken);
 			}
diff --git a/mcs/class/IKVM.Reflection/Emit/ExceptionHandler.cs b/mcs/class/IKVM.Reflection/Emit/ExceptionHandler.cs
new file mode 100644
index 00000000000..40837a97a4a
--- /dev/null
+++ b/mcs/class/IKVM.Reflection/Emit/ExceptionHandler.cs
@@ -0,0 +1,121 @@
+/*
+  Copyright (C) 2012 Jeroen Frijters
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jeroen Frijters
+  jeroen@frijters.net
+  
+*/
+using System;
+using System.Collections.Generic;
+
+namespace IKVM.Reflection.Emit
+{
+	public struct ExceptionHandler : IEquatable<ExceptionHandler>
+	{
+		private readonly int tryOffset;
+		private readonly int tryLength;
+		private readonly int filterOffset;
+		private readonly int handlerOffset;
+		private readonly int handlerLength;
+		private readonly ExceptionHandlingClauseOptions kind;
+		private readonly int exceptionTypeToken;
+
+		public ExceptionHandler(int tryOffset, int tryLength, int filterOffset, int handlerOffset, int handlerLength, ExceptionHandlingClauseOptions kind, int exceptionTypeToken)
+		{
+			if (tryOffset < 0 || tryLength < 0 || filterOffset < 0 || handlerOffset < 0 || handlerLength < 0)
+			{
+				throw new ArgumentOutOfRangeException();
+			}
+			this.tryOffset = tryOffset;
+			this.tryLength = tryLength;
+			this.filterOffset = filterOffset;
+			this.handlerOffset = handlerOffset;
+			this.handlerLength = handlerLength;
+			this.kind = kind;
+			this.exceptionTypeToken = exceptionTypeToken;
+		}
+
+		public int TryOffset
+		{
+			get { return tryOffset; }
+		}
+
+		public int TryLength
+		{
+			get { return tryLength; }
+		}
+
+		public int FilterOffset
+		{
+			get { return filterOffset; }
+		}
+
+		public int HandlerOffset
+		{
+			get { return handlerOffset; }
+		}
+
+		public int HandlerLength
+		{
+			get { return handlerLength; }
+		}
+
+		public ExceptionHandlingClauseOptions Kind
+		{
+			get { return kind; }
+		}
+
+		public int ExceptionTypeToken
+		{
+			get { return exceptionTypeToken; }
+		}
+
+		public bool Equals(ExceptionHandler other)
+		{
+			return tryOffset == other.tryOffset
+				&& tryLength == other.tryLength
+				&& filterOffset == other.filterOffset
+				&& handlerOffset == other.handlerOffset
+				&& handlerLength == other.handlerLength
+				&& kind == other.kind
+				&& exceptionTypeToken == other.exceptionTypeToken;
+		}
+
+		public override bool Equals(object obj)
+		{
+			ExceptionHandler? other = obj as ExceptionHandler?;
+			return other != null && Equals(other);
+		}
+
+		public override int GetHashCode()
+		{
+			return tryOffset ^ tryLength * 33 ^ filterOffset * 333 ^ handlerOffset * 3333 ^ handlerLength * 33333;
+		}
+
+		public static bool operator ==(ExceptionHandler left, ExceptionHandler right)
+		{
+			return left.Equals(right);
+		}
+
+		public static bool operator !=(ExceptionHandler left, ExceptionHandler right)
+		{
+			return !left.Equals(right);
+		}
+	}
+}
diff --git a/mcs/class/IKVM.Reflection/Emit/ILGenerator.cs b/mcs/class/IKVM.Reflection/Emit/ILGenerator.cs
index 7fddd7bcdb6..b7be3f3a981 100644
--- a/mcs/class/IKVM.Reflection/Emit/ILGenerator.cs
+++ b/mcs/class/IKVM.Reflection/Emit/ILGenerator.cs
@@ -71,20 +71,20 @@ namespace IKVM.Reflection.Emit
 		}
 	}
 
-	public sealed class LocalBuilder
+	public sealed class LocalBuilder : LocalVariableInfo
 	{
-		private readonly Type localType;
-		private readonly int index;
-		private readonly bool pinned;
 		internal string name;
 		internal int startOffset;
 		internal int endOffset;
 
 		internal LocalBuilder(Type localType, int index, bool pinned)
+			: base(index, localType, pinned)
+		{
+		}
+
+		internal LocalBuilder(Type localType, int index, bool pinned, CustomModifiers customModifiers)
+			: base(index, localType, pinned, customModifiers)
 		{
-			this.localType = localType;
-			this.index = index;
-			this.pinned = pinned;
 		}
 
 		public void SetLocalSymInfo(string name)
@@ -98,21 +98,6 @@ namespace IKVM.Reflection.Emit
 			this.startOffset = startOffset;
 			this.endOffset = endOffset;
 		}
-
-		public Type LocalType
-		{
-			get { return localType; }
-		}
-
-		public int LocalIndex
-		{
-			get { return index; }
-		}
-
-		public bool IsPinned
-		{
-			get { return pinned; }
-		}
 	}
 
 	public sealed class ILGenerator
@@ -143,7 +128,7 @@ namespace IKVM.Reflection.Emit
 			internal int offset;
 		}
 
-		private sealed class ExceptionBlock : IComparer<ExceptionBlock>
+		internal sealed class ExceptionBlock : IComparer<ExceptionBlock>
 		{
 			internal readonly int ordinal;
 			internal Label labelEnd;
@@ -151,14 +136,25 @@ namespace IKVM.Reflection.Emit
 			internal int tryLength;
 			internal int handlerOffset;
 			internal int handlerLength;
-			internal Type exceptionType;	// MarkerType.Finally = finally block, MarkerType.Filter = handler with filter, MarkerType.Fault = fault block
-			internal int filterOffset;
+			internal int filterOffsetOrExceptionTypeToken;
+			internal ExceptionHandlingClauseOptions kind;
 
 			internal ExceptionBlock(int ordinal)
 			{
 				this.ordinal = ordinal;
 			}
 
+			internal ExceptionBlock(ExceptionHandler h)
+			{
+				this.ordinal = -1;
+				this.tryOffset = h.TryOffset;
+				this.tryLength = h.TryLength;
+				this.handlerOffset = h.HandlerOffset;
+				this.handlerLength = h.HandlerLength;
+				this.kind = h.Kind;
+				this.filterOffsetOrExceptionTypeToken = kind == ExceptionHandlingClauseOptions.Filter ? h.FilterOffset : h.ExceptionTypeToken;
+			}
+
 			int IComparer<ExceptionBlock>.Compare(ExceptionBlock x, ExceptionBlock y)
 			{
 				// Mono's sort insists on doing unnecessary comparisons
@@ -258,56 +254,57 @@ namespace IKVM.Reflection.Emit
 
 		public void BeginCatchBlock(Type exceptionType)
 		{
-			ExceptionBlock block = exceptionStack.Peek();
-			if (exceptionBlockAssistanceMode == EBAM_COMPAT || (exceptionBlockAssistanceMode == EBAM_CLEVER && stackHeight != -1))
+			if (exceptionType == null)
 			{
-				if (exceptionType == null)
+				// this must be a catch block after a filter
+				ExceptionBlock block = exceptionStack.Peek();
+				if (block.kind != ExceptionHandlingClauseOptions.Filter || block.handlerOffset != 0)
 				{
-					Emit(OpCodes.Endfilter);
+					throw new ArgumentNullException("exceptionType");
 				}
-				else
+				if (exceptionBlockAssistanceMode == EBAM_COMPAT || (exceptionBlockAssistanceMode == EBAM_CLEVER && stackHeight != -1))
 				{
-					Emit(OpCodes.Leave, block.labelEnd);
+					Emit(OpCodes.Endfilter);
 				}
+				stackHeight = 0;
+				UpdateStack(1);
+				block.handlerOffset = code.Position;
+			}
+			else
+			{
+				ExceptionBlock block = BeginCatchOrFilterBlock();
+				block.kind = ExceptionHandlingClauseOptions.Clause;
+				block.filterOffsetOrExceptionTypeToken = moduleBuilder.GetTypeTokenForMemberRef(exceptionType);
+				block.handlerOffset = code.Position;
+			}
+		}
+
+		private ExceptionBlock BeginCatchOrFilterBlock()
+		{
+			ExceptionBlock block = exceptionStack.Peek();
+			if (exceptionBlockAssistanceMode == EBAM_COMPAT || (exceptionBlockAssistanceMode == EBAM_CLEVER && stackHeight != -1))
+			{
+				Emit(OpCodes.Leave, block.labelEnd);
 			}
 			stackHeight = 0;
 			UpdateStack(1);
-			if (exceptionType == null)
+			if (block.tryLength == 0)
 			{
-				if (block.exceptionType != MarkerType.Filter || block.handlerOffset != 0)
-				{
-					throw new ArgumentNullException("exceptionType");
-				}
-				block.handlerOffset = code.Position;
+				block.tryLength = code.Position - block.tryOffset;
 			}
 			else
 			{
-				if (block.tryLength == 0)
-				{
-					block.tryLength = code.Position - block.tryOffset;
-				}
-				else
-				{
-					block.handlerLength = code.Position - block.handlerOffset;
-					exceptionStack.Pop();
-					ExceptionBlock newBlock = new ExceptionBlock(exceptions.Count);
-					newBlock.labelEnd = block.labelEnd;
-					newBlock.tryOffset = block.tryOffset;
-					newBlock.tryLength = block.tryLength;
-					block = newBlock;
-					exceptions.Add(block);
-					exceptionStack.Push(block);
-				}
-				block.exceptionType = exceptionType;
-				if (exceptionType == MarkerType.Filter)
-				{
-					block.filterOffset = code.Position;
-				}
-				else
-				{
-					block.handlerOffset = code.Position;
-				}
+				block.handlerLength = code.Position - block.handlerOffset;
+				exceptionStack.Pop();
+				ExceptionBlock newBlock = new ExceptionBlock(exceptions.Count);
+				newBlock.labelEnd = block.labelEnd;
+				newBlock.tryOffset = block.tryOffset;
+				newBlock.tryLength = block.tryLength;
+				block = newBlock;
+				exceptions.Add(block);
+				exceptionStack.Push(block);
 			}
+			return block;
 		}
 
 		public Label BeginExceptionBlock()
@@ -323,20 +320,22 @@ namespace IKVM.Reflection.Emit
 
 		public void BeginExceptFilterBlock()
 		{
-			BeginCatchBlock(MarkerType.Filter);
+			ExceptionBlock block = BeginCatchOrFilterBlock();
+			block.kind = ExceptionHandlingClauseOptions.Filter;
+			block.filterOffsetOrExceptionTypeToken = code.Position;
 		}
 
 		public void BeginFaultBlock()
 		{
-			BeginFinallyFaultBlock(MarkerType.Fault);
+			BeginFinallyFaultBlock(ExceptionHandlingClauseOptions.Fault);
 		}
 
 		public void BeginFinallyBlock()
 		{
-			BeginFinallyFaultBlock(MarkerType.Finally);
+			BeginFinallyFaultBlock(ExceptionHandlingClauseOptions.Finally);
 		}
 
-		private void BeginFinallyFaultBlock(Type type)
+		private void BeginFinallyFaultBlock(ExceptionHandlingClauseOptions kind)
 		{
 			ExceptionBlock block = exceptionStack.Peek();
 			if (exceptionBlockAssistanceMode == EBAM_COMPAT || (exceptionBlockAssistanceMode == EBAM_CLEVER && stackHeight != -1))
@@ -371,7 +370,7 @@ namespace IKVM.Reflection.Emit
 				exceptionStack.Push(block);
 			}
 			block.handlerOffset = code.Position;
-			block.exceptionType = type;
+			block.kind = kind;
 			stackHeight = 0;
 		}
 
@@ -380,7 +379,7 @@ namespace IKVM.Reflection.Emit
 			ExceptionBlock block = exceptionStack.Pop();
 			if (exceptionBlockAssistanceMode == EBAM_COMPAT || (exceptionBlockAssistanceMode == EBAM_CLEVER && stackHeight != -1))
 			{
-				if (block.filterOffset != 0 || (block.exceptionType != MarkerType.Finally && block.exceptionType != MarkerType.Fault))
+				if (block.kind != ExceptionHandlingClauseOptions.Finally && block.kind != ExceptionHandlingClauseOptions.Fault)
 				{
 					Emit(OpCodes.Leave, block.labelEnd);
 				}
@@ -427,7 +426,7 @@ namespace IKVM.Reflection.Emit
 
 		public LocalBuilder __DeclareLocal(Type localType, bool pinned, CustomModifiers customModifiers)
 		{
-			LocalBuilder local = new LocalBuilder(localType, localsCount++, pinned);
+			LocalBuilder local = new LocalBuilder(localType, localsCount++, pinned, customModifiers);
 			locals.__AddArgument(localType, pinned, customModifiers);
 			if (scope != null)
 			{
@@ -494,7 +493,7 @@ namespace IKVM.Reflection.Emit
 		public void Emit(OpCode opc, FieldInfo field)
 		{
 			Emit(opc);
-			WriteToken(moduleBuilder.GetFieldToken(field));
+			WriteToken(moduleBuilder.GetFieldToken(field).Token);
 		}
 
 		public void Emit(OpCode opc, short arg)
@@ -671,22 +670,13 @@ namespace IKVM.Reflection.Emit
 			}
 		}
 
-		private void WriteToken(FieldToken token)
-		{
-			if (token.IsPseudoToken)
-			{
-				tokenFixups.Add(code.Position);
-			}
-			code.Write(token.Token);
-		}
-
-		private void WriteToken(MethodToken token)
+		private void WriteToken(int token)
 		{
-			if (token.IsPseudoToken)
+			if (ModuleBuilder.IsPseudoToken(token))
 			{
 				tokenFixups.Add(code.Position);
 			}
-			code.Write(token.Token);
+			code.Write(token);
 		}
 
 		private void UpdateStack(OpCode opc, bool hasthis, Type returnType, int parameterCount)
@@ -718,7 +708,7 @@ namespace IKVM.Reflection.Emit
 		{
 			UpdateStack(opc, method.HasThis, method.ReturnType, method.ParameterCount);
 			Emit(opc);
-			WriteToken(moduleBuilder.GetMethodTokenForIL(method));
+			WriteToken(moduleBuilder.GetMethodTokenForIL(method).Token);
 		}
 
 		public void Emit(OpCode opc, ConstructorInfo constructor)
@@ -928,7 +918,11 @@ namespace IKVM.Reflection.Emit
 			}
 			else
 			{
-				rva = WriteFatHeaderAndCode(bb, ref localVarSigTok, initLocals);
+				if (localsCount != 0)
+				{
+					localVarSigTok = moduleBuilder.GetSignatureToken(locals).Token;
+				}
+				rva = WriteFatHeaderAndCode(bb, localVarSigTok, initLocals);
 			}
 
 			if (moduleBuilder.symbolWriter != null)
@@ -995,26 +989,23 @@ namespace IKVM.Reflection.Emit
 			}
 		}
 
-		private int WriteTinyHeaderAndCode(ByteBuffer bb)
+		internal static void WriteTinyHeader(ByteBuffer bb, int length)
 		{
-			int rva = bb.Position;
 			const byte CorILMethod_TinyFormat = 0x2;
-			bb.Write((byte)(CorILMethod_TinyFormat | (code.Length << 2)));
-			WriteCode(bb);
-			return rva;
+			bb.Write((byte)(CorILMethod_TinyFormat | (length << 2)));
 		}
 
-		private int WriteFatHeaderAndCode(ByteBuffer bb, ref int localVarSigTok, bool initLocals)
+		private int WriteTinyHeaderAndCode(ByteBuffer bb)
 		{
-			// fat headers require 4-byte alignment
-			bb.Align(4);
 			int rva = bb.Position;
+			WriteTinyHeader(bb, code.Length);
+			AddTokenFixups(bb.Position, moduleBuilder.tokenFixupOffsets, tokenFixups);
+			bb.Write(code);
+			return rva;
+		}
 
-			if (localsCount != 0)
-			{
-				localVarSigTok = moduleBuilder.GetSignatureToken(locals).Token;
-			}
-
+		internal static void WriteFatHeader(ByteBuffer bb, bool initLocals, bool exceptions, ushort maxStack, int codeLength, int localVarSigTok)
+		{
 			const byte CorILMethod_FatFormat = 0x03;
 			const byte CorILMethod_MoreSects = 0x08;
 			const byte CorILMethod_InitLocals = 0x10;
@@ -1025,23 +1016,44 @@ namespace IKVM.Reflection.Emit
 				flagsAndSize |= CorILMethod_InitLocals;
 			}
 
-			if (exceptions.Count > 0)
+			if (exceptions)
 			{
 				flagsAndSize |= CorILMethod_MoreSects;
 			}
 
 			bb.Write(flagsAndSize);
 			bb.Write(maxStack);
-			bb.Write(code.Length);
+			bb.Write(codeLength);
 			bb.Write(localVarSigTok);
+		}
 
-			WriteCode(bb);
-
+		private int WriteFatHeaderAndCode(ByteBuffer bb, int localVarSigTok, bool initLocals)
+		{
+			// fat headers require 4-byte alignment
+			bb.Align(4);
+			int rva = bb.Position;
+			WriteFatHeader(bb, initLocals, exceptions.Count > 0, maxStack, code.Length, localVarSigTok);
+			AddTokenFixups(bb.Position, moduleBuilder.tokenFixupOffsets, tokenFixups);
+			bb.Write(code);
 			if (exceptions.Count > 0)
 			{
-				bb.Align(4);
+				exceptions.Sort(exceptions[0]);
+				WriteExceptionHandlers(bb, exceptions);
+			}
+			return rva;
+		}
 
-				bool fat = false;
+		internal static void WriteExceptionHandlers(ByteBuffer bb, List<ExceptionBlock> exceptions)
+		{
+			bb.Align(4);
+
+			bool fat = false;
+			if (exceptions.Count * 12 + 4 > 255)
+			{
+				fat = true;
+			}
+			else
+			{
 				foreach (ExceptionBlock block in exceptions)
 				{
 					if (block.tryOffset > 65535 || block.tryLength > 255 || block.handlerOffset > 65535 || block.handlerLength > 255)
@@ -1050,105 +1062,50 @@ namespace IKVM.Reflection.Emit
 						break;
 					}
 				}
-				exceptions.Sort(exceptions[0]);
-				if (exceptions.Count * 12 + 4 > 255)
-				{
-					fat = true;
-				}
-				const byte CorILMethod_Sect_EHTable = 0x1;
-				const byte CorILMethod_Sect_FatFormat = 0x40;
-				const short COR_ILEXCEPTION_CLAUSE_EXCEPTION = 0x0000;
-				const short COR_ILEXCEPTION_CLAUSE_FILTER = 0x0001;
-				const short COR_ILEXCEPTION_CLAUSE_FINALLY = 0x0002;
-				const short COR_ILEXCEPTION_CLAUSE_FAULT = 0x0004;
-
-				if (fat)
+			}
+
+			const byte CorILMethod_Sect_EHTable = 0x1;
+			const byte CorILMethod_Sect_FatFormat = 0x40;
+
+			if (fat)
+			{
+				bb.Write((byte)(CorILMethod_Sect_EHTable | CorILMethod_Sect_FatFormat));
+				int dataSize = exceptions.Count * 24 + 4;
+				bb.Write((byte)dataSize);
+				bb.Write((short)(dataSize >> 8));
+				foreach (ExceptionBlock block in exceptions)
 				{
-					bb.Write((byte)(CorILMethod_Sect_EHTable | CorILMethod_Sect_FatFormat));
-					int dataSize = exceptions.Count * 24 + 4;
-					bb.Write((byte)dataSize);
-					bb.Write((short)(dataSize >> 8));
-					foreach (ExceptionBlock block in exceptions)
-					{
-						if (block.exceptionType == MarkerType.Fault)
-						{
-							bb.Write((int)COR_ILEXCEPTION_CLAUSE_FAULT);
-						}
-						else if (block.exceptionType == MarkerType.Filter)
-						{
-							bb.Write((int)COR_ILEXCEPTION_CLAUSE_FILTER);
-						}
-						else if (block.exceptionType == MarkerType.Finally)
-						{
-							bb.Write((int)COR_ILEXCEPTION_CLAUSE_FINALLY);
-						}
-						else
-						{
-							bb.Write((int)COR_ILEXCEPTION_CLAUSE_EXCEPTION);
-						}
-						bb.Write(block.tryOffset);
-						bb.Write(block.tryLength);
-						bb.Write(block.handlerOffset);
-						bb.Write(block.handlerLength);
-						if (block.exceptionType != MarkerType.Fault && block.exceptionType != MarkerType.Filter && block.exceptionType != MarkerType.Finally)
-						{
-							bb.Write(moduleBuilder.GetTypeTokenForMemberRef(block.exceptionType));
-						}
-						else
-						{
-							bb.Write(block.filterOffset);
-						}
-					}
+					bb.Write((int)block.kind);
+					bb.Write(block.tryOffset);
+					bb.Write(block.tryLength);
+					bb.Write(block.handlerOffset);
+					bb.Write(block.handlerLength);
+					bb.Write(block.filterOffsetOrExceptionTypeToken);
 				}
-				else
+			}
+			else
+			{
+				bb.Write(CorILMethod_Sect_EHTable);
+				bb.Write((byte)(exceptions.Count * 12 + 4));
+				bb.Write((short)0);
+				foreach (ExceptionBlock block in exceptions)
 				{
-					bb.Write(CorILMethod_Sect_EHTable);
-					bb.Write((byte)(exceptions.Count * 12 + 4));
-					bb.Write((short)0);
-					foreach (ExceptionBlock block in exceptions)
-					{
-						if (block.exceptionType == MarkerType.Fault)
-						{
-							bb.Write(COR_ILEXCEPTION_CLAUSE_FAULT);
-						}
-						else if (block.exceptionType == MarkerType.Filter)
-						{
-							bb.Write(COR_ILEXCEPTION_CLAUSE_FILTER);
-						}
-						else if (block.exceptionType == MarkerType.Finally)
-						{
-							bb.Write(COR_ILEXCEPTION_CLAUSE_FINALLY);
-						}
-						else
-						{
-							bb.Write(COR_ILEXCEPTION_CLAUSE_EXCEPTION);
-						}
-						bb.Write((short)block.tryOffset);
-						bb.Write((byte)block.tryLength);
-						bb.Write((short)block.handlerOffset);
-						bb.Write((byte)block.handlerLength);
-						if (block.exceptionType != MarkerType.Fault && block.exceptionType != MarkerType.Filter && block.exceptionType != MarkerType.Finally)
-						{
-							bb.Write(moduleBuilder.GetTypeTokenForMemberRef(block.exceptionType));
-						}
-						else
-						{
-							bb.Write(block.filterOffset);
-						}
-					}
+					bb.Write((short)block.kind);
+					bb.Write((short)block.tryOffset);
+					bb.Write((byte)block.tryLength);
+					bb.Write((short)block.handlerOffset);
+					bb.Write((byte)block.handlerLength);
+					bb.Write(block.filterOffsetOrExceptionTypeToken);
 				}
 			}
-			return rva;
 		}
 
-		private void WriteCode(ByteBuffer bb)
+		internal static void AddTokenFixups(int codeOffset, List<int> tokenFixupOffsets, IEnumerable<int> tokenFixups)
 		{
-			int codeOffset = bb.Position;
-			foreach (int fixup in this.tokenFixups)
+			foreach (int fixup in tokenFixups)
 			{
-				moduleBuilder.tokenFixupOffsets.Add(fixup + codeOffset);
+				tokenFixupOffsets.Add(fixup + codeOffset);
 			}
-			bb.Write(code);
 		}
 
 		private void WriteScope(Scope scope, int localVarSigTok)
diff --git a/mcs/class/IKVM.Reflection/Emit/MethodBuilder.cs b/mcs/class/IKVM.Reflection/Emit/MethodBuilder.cs
index 89778acdb47..486e74c91ad 100644
--- a/mcs/class/IKVM.Reflection/Emit/MethodBuilder.cs
+++ b/mcs/class/IKVM.Reflection/Emit/MethodBuilder.cs
@@ -367,6 +367,10 @@ namespace IKVM.Reflection.Emit
 		public GenericTypeParameterBuilder[] DefineGenericParameters(params string[] names)
 		{
 			CheckSig();
+			if (gtpb != null)
+			{
+				throw new InvalidOperationException("Generic parameters already defined.");
+			}
 			gtpb = new GenericTypeParameterBuilder[names.Length];
 			for (int i = 0; i < names.Length; i++)
 			{
@@ -622,6 +626,54 @@ namespace IKVM.Reflection.Emit
 			this.ModuleBuilder.AddUnmanagedExport(name, ordinal, this, new RelativeVirtualAddress(0xFFFFFFFF));
 		}
 
+		public void CreateMethodBody(byte[] il, int count)
+		{
+			if (il == null)
+			{
+				throw new NotSupportedException();
+			}
+			if (il.Length != count)
+			{
+				Array.Resize(ref il, count);
+			}
+			SetMethodBody(il, 16, null, null, null);
+		}
+
+		public void SetMethodBody(byte[] il, int maxStack, byte[] localSignature, IEnumerable<ExceptionHandler> exceptionHandlers, IEnumerable<int> tokenFixups)
+		{
+			ByteBuffer bb = this.ModuleBuilder.methodBodies;
+
+			if (localSignature == null && exceptionHandlers == null && maxStack <= 8 && il.Length < 64)
+			{
+				rva = bb.Position;
+				ILGenerator.WriteTinyHeader(bb, il.Length);
+			}
+			else
+			{
+				// fat headers require 4-byte alignment
+				bb.Align(4);
+				rva = bb.Position;
+				ILGenerator.WriteFatHeader(bb, initLocals, exceptionHandlers != null, (ushort)maxStack, il.Length,
+					localSignature == null ? 0 : this.ModuleBuilder.GetSignatureToken(localSignature, localSignature.Length).Token);
+			}
+
+			if (tokenFixups != null)
+			{
+				ILGenerator.AddTokenFixups(bb.Position, this.ModuleBuilder.tokenFixupOffsets, tokenFixups);
+			}
+			bb.Write(il);
+
+			if (exceptionHandlers != null)
+			{
+				List<ILGenerator.ExceptionBlock> exceptions = new List<ILGenerator.ExceptionBlock>();
+				foreach (ExceptionHandler block in exceptionHandlers)
+				{
+					exceptions.Add(new ILGenerator.ExceptionBlock(block));
+				}
+				ILGenerator.WriteExceptionHandlers(bb, exceptions);
+			}
+		}
+
 		internal void Bake()
 		{
 			this.nameIndex = this.ModuleBuilder.Strings.Add(name);
diff --git a/mcs/class/IKVM.Reflection/Emit/ModuleBuilder.cs b/mcs/class/IKVM.Reflection/Emit/ModuleBuilder.cs
index 8ffe17ba957..7a64f248a19 100644
--- a/mcs/class/IKVM.Reflection/Emit/ModuleBuilder.cs
+++ b/mcs/class/IKVM.Reflection/Emit/ModuleBuilder.cs
@@ -401,7 +401,6 @@ namespace IKVM.Reflection.Emit
 		private int ExportType(Type type)
 		{
 			ExportedTypeTable.Record rec = new ExportedTypeTable.Record();
-			rec.TypeDefId = type.MetadataToken;
 			rec.TypeName = this.Strings.Add(type.__Name);
 			string ns = type.__Namespace;
 			rec.TypeNamespace = ns == null ? 0 : this.Strings.Add(ns);
@@ -492,13 +491,13 @@ namespace IKVM.Reflection.Emit
 			ByteBuffer namedArgs = new ByteBuffer(100);
 			ByteBuffer bb = new ByteBuffer(list.Count * 100);
 			bb.Write((byte)'.');
-			bb.WriteCompressedInt(list.Count);
+			bb.WriteCompressedUInt(list.Count);
 			foreach (CustomAttributeBuilder cab in list)
 			{
 				bb.Write(cab.Constructor.DeclaringType.AssemblyQualifiedName);
 				namedArgs.Clear();
 				cab.WriteNamedArgumentsForDeclSecurity(this, namedArgs);
-				bb.WriteCompressedInt(namedArgs.Length);
+				bb.WriteCompressedUInt(namedArgs.Length);
 				bb.Write(namedArgs);
 			}
 			return this.Blobs.Add(bb);
@@ -920,7 +919,7 @@ namespace IKVM.Reflection.Emit
 			resolvedTokens[index] = realToken;
 		}
 
-		internal bool IsPseudoToken(int token)
+		internal static bool IsPseudoToken(int token)
 		{
 			return token < 0;
 		}
diff --git a/mcs/class/IKVM.Reflection/Emit/PropertyBuilder.cs b/mcs/class/IKVM.Reflection/Emit/PropertyBuilder.cs
index 2900f7abb5f..6e3c741c8fa 100644
--- a/mcs/class/IKVM.Reflection/Emit/PropertyBuilder.cs
+++ b/mcs/class/IKVM.Reflection/Emit/PropertyBuilder.cs
@@ -275,7 +275,7 @@ namespace IKVM.Reflection.Emit
 
 		internal override int GetCurrentToken()
 		{
-			if (typeBuilder.ModuleBuilder.IsSaved && typeBuilder.ModuleBuilder.IsPseudoToken(lazyPseudoToken))
+			if (typeBuilder.ModuleBuilder.IsSaved && ModuleBuilder.IsPseudoToken(lazyPseudoToken))
 			{
 				return typeBuilder.ModuleBuilder.ResolvePseudoToken(lazyPseudoToken);
 			}
diff --git a/mcs/class/IKVM.Reflection/Emit/SignatureHelper.cs b/mcs/class/IKVM.Reflection/Emit/SignatureHelper.cs
index b70ace82169..64dc18d2804 100644
--- a/mcs/class/IKVM.Reflection/Emit/SignatureHelper.cs
+++ b/mcs/class/IKVM.Reflection/Emit/SignatureHelper.cs
@@ -115,8 +115,8 @@ namespace IKVM.Reflection.Emit
 				if (type != Signature.FIELD)
 				{
 					bb.Position = 1;
-					bb.Insert(MetadataWriter.GetCompressedIntLength(paramCount) - bb.GetCompressedIntLength());
-					bb.WriteCompressedInt(paramCount);
+					bb.Insert(MetadataWriter.GetCompressedUIntLength(paramCount) - bb.GetCompressedUIntLength());
+					bb.WriteCompressedUInt(paramCount);
 				}
 				return bb;
 			}
diff --git a/mcs/class/IKVM.Reflection/Emit/Tokens.cs b/mcs/class/IKVM.Reflection/Emit/Tokens.cs
index 49ac4c6adb9..9b39f29c8ef 100644
--- a/mcs/class/IKVM.Reflection/Emit/Tokens.cs
+++ b/mcs/class/IKVM.Reflection/Emit/Tokens.cs
@@ -75,11 +75,6 @@ namespace IKVM.Reflection.Emit
 			this.token = token;
 		}
 
-		internal bool IsPseudoToken
-		{
-			get { return token < 0; }
-		}
-
 		public int Token
 		{
 			get { return token; }
@@ -121,11 +116,6 @@ namespace IKVM.Reflection.Emit
 			this.token = token;
 		}
 
-		internal bool IsPseudoToken
-		{
-			get { return token < 0; }
-		}
-
 		public int Token
 		{
 			get { return token; }
diff --git a/mcs/class/IKVM.Reflection/Emit/TypeBuilder.cs b/mcs/class/IKVM.Reflection/Emit/TypeBuilder.cs
index b9f2a8f4b78..aa6d2642907 100644
--- a/mcs/class/IKVM.Reflection/Emit/TypeBuilder.cs
+++ b/mcs/class/IKVM.Reflection/Emit/TypeBuilder.cs
@@ -397,6 +397,11 @@ namespace IKVM.Reflection.Emit
 			return DefineProperty(name, attributes, returnType, null, null, parameterTypes, null, null);
 		}
 
+		public PropertyBuilder DefineProperty(string name, PropertyAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
+		{
+			return DefineProperty(name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null);
+		}
+
 		public PropertyBuilder DefineProperty(string name, PropertyAttributes attributes, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers,
 			Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)
 		{
@@ -481,7 +486,7 @@ namespace IKVM.Reflection.Emit
 			return DefineNestedType(name, attr, parent, packSize, 0);
 		}
 
-		private TypeBuilder DefineNestedType(string name, TypeAttributes attr, Type parent, PackingSize packSize, int typeSize)
+		public TypeBuilder DefineNestedType(string name, TypeAttributes attr, Type parent, PackingSize packSize, int typeSize)
 		{
 			string ns = null;
 			int lastdot = name.LastIndexOf('.');
@@ -689,7 +694,7 @@ namespace IKVM.Reflection.Emit
 			return this;
 		}
 
-		public Type CreateType()
+		public TypeInfo CreateTypeInfo()
 		{
 			if ((typeFlags & TypeFlags.Baked) != 0)
 			{
@@ -711,7 +716,7 @@ namespace IKVM.Reflection.Emit
 				hasConstructor |= mb.IsSpecialName && mb.Name == ConstructorInfo.ConstructorName;
 				mb.Bake();
 			}
-			if (!hasConstructor && !IsModulePseudoType && !IsInterface && !IsValueType && !(IsAbstract && IsSealed))
+			if (!hasConstructor && !IsModulePseudoType && !IsInterface && !IsValueType && !(IsAbstract && IsSealed) && Universe.AutomaticallyProvideDefaultConstructor)
 			{
 				((MethodBuilder)DefineDefaultConstructor(MethodAttributes.Public).GetMethodInfo()).Bake();
 			}
@@ -740,6 +745,11 @@ namespace IKVM.Reflection.Emit
 			return new BakedType(this);
 		}
 
+		public Type CreateType()
+		{
+			return CreateTypeInfo();
+		}
+
 		internal void PopulatePropertyAndEventTables()
 		{
 			if (properties != null)
diff --git a/mcs/class/IKVM.Reflection/Enums.cs b/mcs/class/IKVM.Reflection/Enums.cs
index 2ff8de990bd..9fcbb6d0433 100644
--- a/mcs/class/IKVM.Reflection/Enums.cs
+++ b/mcs/class/IKVM.Reflection/Enums.cs
@@ -222,7 +222,8 @@ namespace IKVM.Reflection
 		IA64 = 3,
 		Amd64 = 4,
 		Arm = 5,
-		// if an item is added here, make sure to update AssemblyName.ProcessorArchitecture and Fusion.ParseAssemblyName as well
+		// if an item is added here, make sure to update AssemblyName.ProcessorArchitecture,
+		// AssemblyReader.GetNameImpl() and Fusion.ParseAssemblyName as well
 	}
 
 	[Flags]
diff --git a/mcs/class/IKVM.Reflection/EventInfo.cs b/mcs/class/IKVM.Reflection/EventInfo.cs
index ffd9a0df32d..d8f3c03a4be 100644
--- a/mcs/class/IKVM.Reflection/EventInfo.cs
+++ b/mcs/class/IKVM.Reflection/EventInfo.cs
@@ -74,6 +74,21 @@ namespace IKVM.Reflection
 			return GetOtherMethods(false);
 		}
 
+		public MethodInfo AddMethod
+		{
+			get { return GetAddMethod(true); }
+		}
+
+		public MethodInfo RaiseMethod
+		{
+			get { return GetRaiseMethod(true); }
+		}
+
+		public MethodInfo RemoveMethod
+		{
+			get { return GetRemoveMethod(true); }
+		}
+
 		internal virtual EventInfo BindTypeParameters(Type type)
 		{
 			return new GenericEventInfo(this.DeclaringType.BindTypeParameters(type), this);
diff --git a/mcs/class/IKVM.Reflection/Fusion.cs b/mcs/class/IKVM.Reflection/Fusion.cs
index d9c0e086110..0d0f8ec14cb 100644
--- a/mcs/class/IKVM.Reflection/Fusion.cs
+++ b/mcs/class/IKVM.Reflection/Fusion.cs
@@ -510,14 +510,7 @@ namespace IKVM.Reflection
 				publicKeyToken = null;
 				return false;
 			}
-			// HACK use AssemblyName to convert PublicKey to PublicKeyToken
-			byte[] token = new System.Reflection.AssemblyName("Foo, PublicKey=" + str).GetPublicKeyToken();
-			StringBuilder sb = new StringBuilder(token.Length * 2);
-			for (int i = 0; i < token.Length; i++)
-			{
-				sb.AppendFormat("{0:x2}", token[i]);
-			}
-			publicKeyToken = sb.ToString();
+			publicKeyToken = AssemblyName.ComputePublicKeyToken(str);
 			return true;
 		}
 
diff --git a/mcs/class/IKVM.Reflection/IKVM.Reflection.csproj b/mcs/class/IKVM.Reflection/IKVM.Reflection.csproj
index e7e7ad30cf2..540e037beda 100644
--- a/mcs/class/IKVM.Reflection/IKVM.Reflection.csproj
+++ b/mcs/class/IKVM.Reflection/IKVM.Reflection.csproj
@@ -58,6 +58,7 @@
     <Compile Include="Emit\EnumBuilder.cs" />
     <Compile Include="Emit\Enums.cs" />
     <Compile Include="Emit\EventBuilder.cs" />
+    <Compile Include="Emit\ExceptionHandler.cs" />
     <Compile Include="Emit\FieldBuilder.cs" />
     <Compile Include="Emit\ILGenerator.cs" />
     <Compile Include="Emit\MethodBuilder.cs" />
@@ -100,6 +101,7 @@
     <Compile Include="PropertyInfo.cs" />
     <Compile Include="PropertySignature.cs" />
     <Compile Include="Reader\AssemblyReader.cs" />
+    <Compile Include="Reader\Authenticode.cs" />
     <Compile Include="Reader\ByteReader.cs" />
     <Compile Include="Reader\EventInfoImpl.cs" />
     <Compile Include="Reader\Field.cs" />
@@ -116,6 +118,7 @@
     <Compile Include="StrongNameKeyPair.cs" />
     <Compile Include="Type.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TypeInfo.cs" />
     <Compile Include="TypeNameParser.cs" />
     <Compile Include="Universe.cs" />
     <Compile Include="Util.cs" />
@@ -130,6 +133,7 @@
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System" />
+    <Reference Include="System.Security" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/mcs/class/IKVM.Reflection/LocalVariableInfo.cs b/mcs/class/IKVM.Reflection/LocalVariableInfo.cs
index e7f056781c2..9d565aa2139 100644
--- a/mcs/class/IKVM.Reflection/LocalVariableInfo.cs
+++ b/mcs/class/IKVM.Reflection/LocalVariableInfo.cs
@@ -25,18 +25,23 @@ using System;
 
 namespace IKVM.Reflection
 {
-	public sealed class LocalVariableInfo
+	public class LocalVariableInfo
 	{
 		private readonly int index;
 		private readonly Type type;
 		private readonly bool pinned;
 		private readonly CustomModifiers customModifiers;
 
-		internal LocalVariableInfo(int index, Type type, bool pinned, CustomModifiers customModifiers)
+		internal LocalVariableInfo(int index, Type type, bool pinned)
 		{
 			this.index = index;
 			this.type = type;
 			this.pinned = pinned;
+		}
+
+		internal LocalVariableInfo(int index, Type type, bool pinned, CustomModifiers customModifiers)
+			: this(index, type, pinned)
+		{
 			this.customModifiers = customModifiers;
 		}
 
@@ -59,5 +64,10 @@ namespace IKVM.Reflection
 		{
 			return customModifiers;
 		}
+
+		public override string ToString()
+		{
+			return String.Format(pinned ? "{0} ({1}) (pinned)" : "{0} ({1})", type, index);
+		}
 	}
 }
diff --git a/mcs/class/IKVM.Reflection/MarshalSpec.cs b/mcs/class/IKVM.Reflection/MarshalSpec.cs
index f568a68bb98..ee5314dfd96 100644
--- a/mcs/class/IKVM.Reflection/MarshalSpec.cs
+++ b/mcs/class/IKVM.Reflection/MarshalSpec.cs
@@ -52,21 +52,21 @@ namespace IKVM.Reflection
 			foreach (int i in module.FieldMarshal.Filter(token))
 			{
 				ByteReader blob = module.GetBlob(module.FieldMarshal.records[i].NativeType);
-				fm.UnmanagedType = (UnmanagedType)blob.ReadCompressedInt();
+				fm.UnmanagedType = (UnmanagedType)blob.ReadCompressedUInt();
 				if (fm.UnmanagedType == UnmanagedType.LPArray)
 				{
-					fm.ArraySubType = (UnmanagedType)blob.ReadCompressedInt();
+					fm.ArraySubType = (UnmanagedType)blob.ReadCompressedUInt();
 					if (fm.ArraySubType == NATIVE_TYPE_MAX)
 					{
 						fm.ArraySubType = null;
 					}
 					if (blob.Length != 0)
 					{
-						fm.SizeParamIndex = (short)blob.ReadCompressedInt();
+						fm.SizeParamIndex = (short)blob.ReadCompressedUInt();
 						if (blob.Length != 0)
 						{
-							fm.SizeConst = blob.ReadCompressedInt();
-							if (blob.Length != 0 && blob.ReadCompressedInt() == 0)
+							fm.SizeConst = blob.ReadCompressedUInt();
+							if (blob.Length != 0 && blob.ReadCompressedUInt() == 0)
 							{
 								fm.SizeParamIndex = null;
 							}
@@ -77,7 +77,7 @@ namespace IKVM.Reflection
 				{
 					if (blob.Length != 0)
 					{
-						fm.SafeArraySubType = (VarEnum)blob.ReadCompressedInt();
+						fm.SafeArraySubType = (VarEnum)blob.ReadCompressedUInt();
 						if (blob.Length != 0)
 						{
 							fm.SafeArrayUserDefinedSubType = ReadType(module, blob);
@@ -86,15 +86,15 @@ namespace IKVM.Reflection
 				}
 				else if (fm.UnmanagedType == UnmanagedType.ByValArray)
 				{
-					fm.SizeConst = blob.ReadCompressedInt();
+					fm.SizeConst = blob.ReadCompressedUInt();
 					if (blob.Length != 0)
 					{
-						fm.ArraySubType = (UnmanagedType)blob.ReadCompressedInt();
+						fm.ArraySubType = (UnmanagedType)blob.ReadCompressedUInt();
 					}
 				}
 				else if (fm.UnmanagedType == UnmanagedType.ByValTStr)
 				{
-					fm.SizeConst = blob.ReadCompressedInt();
+					fm.SizeConst = blob.ReadCompressedUInt();
 				}
 				else if (fm.UnmanagedType == UnmanagedType.Interface
 					|| fm.UnmanagedType == UnmanagedType.IDispatch
@@ -102,13 +102,13 @@ namespace IKVM.Reflection
 				{
 					if (blob.Length != 0)
 					{
-						fm.IidParameterIndex = blob.ReadCompressedInt();
+						fm.IidParameterIndex = blob.ReadCompressedUInt();
 					}
 				}
 				else if (fm.UnmanagedType == UnmanagedType.CustomMarshaler)
 				{
-					blob.ReadCompressedInt();
-					blob.ReadCompressedInt();
+					blob.ReadCompressedUInt();
+					blob.ReadCompressedUInt();
 					fm.MarshalType = ReadString(blob);
 					fm.MarshalCookie = ReadString(blob);
 
@@ -150,28 +150,28 @@ namespace IKVM.Reflection
 			}
 
 			ByteBuffer bb = new ByteBuffer(5);
-			bb.WriteCompressedInt((int)unmanagedType);
+			bb.WriteCompressedUInt((int)unmanagedType);
 
 			if (unmanagedType == UnmanagedType.LPArray)
 			{
 				UnmanagedType arraySubType = attribute.GetFieldValue<UnmanagedType>("ArraySubType") ?? NATIVE_TYPE_MAX;
-				bb.WriteCompressedInt((int)arraySubType);
+				bb.WriteCompressedUInt((int)arraySubType);
 				int? sizeParamIndex = attribute.GetFieldValue<short>("SizeParamIndex");
 				int? sizeConst = attribute.GetFieldValue<int>("SizeConst");
 				if (sizeParamIndex != null)
 				{
-					bb.WriteCompressedInt(sizeParamIndex.Value);
+					bb.WriteCompressedUInt(sizeParamIndex.Value);
 					if (sizeConst != null)
 					{
-						bb.WriteCompressedInt(sizeConst.Value);
-						bb.WriteCompressedInt(1); // flag that says that SizeParamIndex was specified
+						bb.WriteCompressedUInt(sizeConst.Value);
+						bb.WriteCompressedUInt(1); // flag that says that SizeParamIndex was specified
 					}
 				}
 				else if (sizeConst != null)
 				{
-					bb.WriteCompressedInt(0); // SizeParamIndex
-					bb.WriteCompressedInt(sizeConst.Value);
-					bb.WriteCompressedInt(0); // flag that says that SizeParamIndex was not specified
+					bb.WriteCompressedUInt(0); // SizeParamIndex
+					bb.WriteCompressedUInt(sizeConst.Value);
+					bb.WriteCompressedUInt(0); // flag that says that SizeParamIndex was not specified
 				}
 			}
 			else if (unmanagedType == UnmanagedType.SafeArray)
@@ -179,7 +179,7 @@ namespace IKVM.Reflection
 				VarEnum? safeArraySubType = attribute.GetFieldValue<VarEnum>("SafeArraySubType");
 				if (safeArraySubType != null)
 				{
-					bb.WriteCompressedInt((int)safeArraySubType);
+					bb.WriteCompressedUInt((int)safeArraySubType);
 					Type safeArrayUserDefinedSubType = (Type)attribute.GetFieldValue("SafeArrayUserDefinedSubType");
 					if (safeArrayUserDefinedSubType != null)
 					{
@@ -189,16 +189,16 @@ namespace IKVM.Reflection
 			}
 			else if (unmanagedType == UnmanagedType.ByValArray)
 			{
-				bb.WriteCompressedInt(attribute.GetFieldValue<int>("SizeConst") ?? 1);
+				bb.WriteCompressedUInt(attribute.GetFieldValue<int>("SizeConst") ?? 1);
 				UnmanagedType? arraySubType = attribute.GetFieldValue<UnmanagedType>("ArraySubType");
 				if (arraySubType != null)
 				{
-					bb.WriteCompressedInt((int)arraySubType);
+					bb.WriteCompressedUInt((int)arraySubType);
 				}
 			}
 			else if (unmanagedType == UnmanagedType.ByValTStr)
 			{
-				bb.WriteCompressedInt(attribute.GetFieldValue<int>("SizeConst").Value);
+				bb.WriteCompressedUInt(attribute.GetFieldValue<int>("SizeConst").Value);
 			}
 			else if (unmanagedType == UnmanagedType.Interface
 				|| unmanagedType == UnmanagedType.IDispatch
@@ -207,13 +207,13 @@ namespace IKVM.Reflection
 				int? iidParameterIndex = attribute.GetFieldValue<int>("IidParameterIndex");
 				if (iidParameterIndex != null)
 				{
-					bb.WriteCompressedInt(iidParameterIndex.Value);
+					bb.WriteCompressedUInt(iidParameterIndex.Value);
 				}
 			}
 			else if (unmanagedType == UnmanagedType.CustomMarshaler)
 			{
-				bb.WriteCompressedInt(0);
-				bb.WriteCompressedInt(0);
+				bb.WriteCompressedUInt(0);
+				bb.WriteCompressedUInt(0);
 				string marshalType = (string)attribute.GetFieldValue("MarshalType");
 				if (marshalType != null)
 				{
@@ -246,13 +246,13 @@ namespace IKVM.Reflection
 
 		private static string ReadString(ByteReader br)
 		{
-			return Encoding.UTF8.GetString(br.ReadBytes(br.ReadCompressedInt()));
+			return Encoding.UTF8.GetString(br.ReadBytes(br.ReadCompressedUInt()));
 		}
 
 		private static void WriteString(ByteBuffer bb, string str)
 		{
 			byte[] buf = Encoding.UTF8.GetBytes(str);
-			bb.WriteCompressedInt(buf.Length);
+			bb.WriteCompressedUInt(buf.Length);
 			bb.Write(buf);
 		}
 	}
diff --git a/mcs/class/IKVM.Reflection/MemberInfo.cs b/mcs/class/IKVM.Reflection/MemberInfo.cs
index 0f9438c8ca0..1a8173b4387 100644
--- a/mcs/class/IKVM.Reflection/MemberInfo.cs
+++ b/mcs/class/IKVM.Reflection/MemberInfo.cs
@@ -74,6 +74,16 @@ namespace IKVM.Reflection
 			return CustomAttributeData.__GetCustomAttributes(this, attributeType, inherit);
 		}
 
+		public IList<CustomAttributeData> GetCustomAttributesData()
+		{
+			return CustomAttributeData.GetCustomAttributes(this);
+		}
+
+		public IEnumerable<CustomAttributeData> CustomAttributes
+		{
+			get { return GetCustomAttributesData(); }
+		}
+
 		public static bool operator ==(MemberInfo m1, MemberInfo m2)
 		{
 			return ReferenceEquals(m1, m2) || (!ReferenceEquals(m1, null) && m1.Equals(m2));
diff --git a/mcs/class/IKVM.Reflection/Metadata/CliHeader.cs b/mcs/class/IKVM.Reflection/Metadata/CliHeader.cs
index 32812290f7e..cb2574ba639 100644
--- a/mcs/class/IKVM.Reflection/Metadata/CliHeader.cs
+++ b/mcs/class/IKVM.Reflection/Metadata/CliHeader.cs
@@ -22,10 +22,27 @@
   
 */
 using System.IO;
-using IMAGE_DATA_DIRECTORY = IKVM.Reflection.Reader.IMAGE_DATA_DIRECTORY;
 
 namespace IKVM.Reflection.Metadata
 {
+	struct RvaSize
+	{
+		internal uint VirtualAddress;
+		internal uint Size;
+
+		internal void Read(BinaryReader br)
+		{
+			VirtualAddress = br.ReadUInt32();
+			Size = br.ReadUInt32();
+		}
+
+		internal void Write(IKVM.Reflection.Writer.MetadataWriter mw)
+		{
+			mw.Write(VirtualAddress);
+			mw.Write(Size);
+		}
+	}
+
 	sealed class CliHeader
 	{
 		internal const uint COMIMAGE_FLAGS_ILONLY = 0x00000001;
@@ -37,15 +54,15 @@ namespace IKVM.Reflection.Metadata
 		internal uint Cb = 0x48;
 		internal ushort MajorRuntimeVersion;
 		internal ushort MinorRuntimeVersion;
-		internal IMAGE_DATA_DIRECTORY MetaData;
+		internal RvaSize MetaData;
 		internal uint Flags;
 		internal uint EntryPointToken;
-		internal IMAGE_DATA_DIRECTORY Resources;
-		internal IMAGE_DATA_DIRECTORY StrongNameSignature;
-		internal IMAGE_DATA_DIRECTORY CodeManagerTable;
-		internal IMAGE_DATA_DIRECTORY VTableFixups;
-		internal IMAGE_DATA_DIRECTORY ExportAddressTableJumps;
-		internal IMAGE_DATA_DIRECTORY ManagedNativeHeader;
+		internal RvaSize Resources;
+		internal RvaSize StrongNameSignature;
+		internal RvaSize CodeManagerTable;
+		internal RvaSize VTableFixups;
+		internal RvaSize ExportAddressTableJumps;
+		internal RvaSize ManagedNativeHeader;
 
 		internal void Read(BinaryReader br)
 		{
diff --git a/mcs/class/IKVM.Reflection/Metadata/Tables.cs b/mcs/class/IKVM.Reflection/Metadata/Tables.cs
index ad61cb04e77..b35debf741c 100644
--- a/mcs/class/IKVM.Reflection/Metadata/Tables.cs
+++ b/mcs/class/IKVM.Reflection/Metadata/Tables.cs
@@ -388,7 +388,7 @@ namespace IKVM.Reflection.Metadata
 
 	abstract class Table<T> : Table
 	{
-		internal T[] records = new T[1];
+		internal T[] records = Empty<T>.Array;
 		protected int rowCount;
 
 		internal sealed override int RowCount
@@ -406,9 +406,7 @@ namespace IKVM.Reflection.Metadata
 		{
 			if (rowCount == records.Length)
 			{
-				T[] newarr = new T[records.Length * 2];
-				Array.Copy(records, newarr, records.Length);
-				records = newarr;
+				Array.Resize(ref records, Math.Max(16, records.Length * 2));
 			}
 			records[rowCount++] = newRecord;
 			return rowCount;
diff --git a/mcs/class/IKVM.Reflection/MethodBase.cs b/mcs/class/IKVM.Reflection/MethodBase.cs
index 1bf10e2c420..f3810ec26f6 100644
--- a/mcs/class/IKVM.Reflection/MethodBase.cs
+++ b/mcs/class/IKVM.Reflection/MethodBase.cs
@@ -114,6 +114,11 @@ namespace IKVM.Reflection
 			get { return (Attributes & MethodAttributes.HideBySig) != 0; }
 		}
 
+		public MethodImplAttributes MethodImplementationFlags
+		{
+			get { return GetMethodImplementationFlags(); }
+		}
+
 		public virtual Type[] GetGenericArguments()
 		{
 			return Type.EmptyTypes;
diff --git a/mcs/class/IKVM.Reflection/MethodSignature.cs b/mcs/class/IKVM.Reflection/MethodSignature.cs
index 76c9cb505b0..9a3c31460c3 100644
--- a/mcs/class/IKVM.Reflection/MethodSignature.cs
+++ b/mcs/class/IKVM.Reflection/MethodSignature.cs
@@ -115,10 +115,10 @@ namespace IKVM.Reflection
 			genericParamCount = 0;
 			if ((flags & GENERIC) != 0)
 			{
-				genericParamCount = br.ReadCompressedInt();
+				genericParamCount = br.ReadCompressedUInt();
 				context = new UnboundGenericMethodContext(context);
 			}
-			int paramCount = br.ReadCompressedInt();
+			int paramCount = br.ReadCompressedUInt();
 			CustomModifiers[] modifiers = null;
 			PackedCustomModifiers.Pack(ref modifiers, 0, CustomModifiers.Read(module, br, context), paramCount + 1);
 			returnType = ReadRetType(module, br, context);
@@ -187,7 +187,7 @@ namespace IKVM.Reflection
 			{
 				throw new BadImageFormatException();
 			}
-			int paramCount = br.ReadCompressedInt();
+			int paramCount = br.ReadCompressedUInt();
 			CustomModifiers[] customModifiers = null;
 			PackedCustomModifiers.Pack(ref customModifiers, 0, CustomModifiers.Read(module, br, context), paramCount + 1);
 			Type returnType = ReadRetType(module, br, context);
@@ -368,9 +368,9 @@ namespace IKVM.Reflection
 			bb.Write(first);
 			if (genericParamCount > 0)
 			{
-				bb.WriteCompressedInt(genericParamCount);
+				bb.WriteCompressedUInt(genericParamCount);
 			}
-			bb.WriteCompressedInt(parameterCount);
+			bb.WriteCompressedUInt(parameterCount);
 			// RetType
 			WriteCustomModifiers(module, bb, modifiers.GetReturnTypeCustomModifiers());
 			WriteType(module, bb, returnType);
diff --git a/mcs/class/IKVM.Reflection/Missing.cs b/mcs/class/IKVM.Reflection/Missing.cs
index 6d2364b01b6..67c0a85ae3d 100644
--- a/mcs/class/IKVM.Reflection/Missing.cs
+++ b/mcs/class/IKVM.Reflection/Missing.cs
@@ -236,9 +236,9 @@ namespace IKVM.Reflection
 
 	sealed class MissingModule : NonPEModule
 	{
-		private readonly MissingAssembly assembly;
+		private readonly Assembly assembly;
 
-		internal MissingModule(MissingAssembly assembly)
+		internal MissingModule(Assembly assembly)
 			: base(assembly.universe)
 		{
 			this.assembly = assembly;
@@ -353,6 +353,7 @@ namespace IKVM.Reflection
 		private readonly string name;
 		private Type[] typeArgs;
 		private int token;
+		private int flags;
 
 		internal MissingType(Module module, Type declaringType, string ns, string name)
 		{
@@ -545,9 +546,10 @@ namespace IKVM.Reflection
 			return this;
 		}
 
-		internal override Type SetMetadataTokenForMissing(int token)
+		internal override Type SetMetadataTokenForMissing(int token, int flags)
 		{
 			this.token = token;
+			this.flags = flags;
 			return this;
 		}
 
@@ -555,6 +557,12 @@ namespace IKVM.Reflection
 		{
 			get { throw new MissingMemberException(this); }
 		}
+
+		public override bool __IsTypeForwarder
+		{
+			// CorTypeAttr.tdForwarder
+			get { return (flags & 0x00200000) != 0; }
+		}
 	}
 
 	sealed class MissingTypeParameter : IKVM.Reflection.Reader.TypeParameterType
diff --git a/mcs/class/IKVM.Reflection/Module.cs b/mcs/class/IKVM.Reflection/Module.cs
index d734aae2077..191a98dedbe 100644
--- a/mcs/class/IKVM.Reflection/Module.cs
+++ b/mcs/class/IKVM.Reflection/Module.cs
@@ -447,6 +447,16 @@ namespace IKVM.Reflection
 			return CustomAttributeData.__GetCustomAttributes(this, attributeType, inherit);
 		}
 
+		public IList<CustomAttributeData> GetCustomAttributesData()
+		{
+			return CustomAttributeData.GetCustomAttributes(this);
+		}
+
+		public IEnumerable<CustomAttributeData> CustomAttributes
+		{
+			get { return GetCustomAttributesData(); }
+		}
+
 		public virtual IList<CustomAttributeData> __GetPlaceholderAssemblyCustomAttributes(bool multiple, bool security)
 		{
 			return Empty<CustomAttributeData>.Array;
@@ -534,6 +544,11 @@ namespace IKVM.Reflection
 			return CustomAttributeData.GetCustomAttributesImpl(new List<CustomAttributeData>(), this, token, null);
 		}
 
+		public virtual System.Security.Cryptography.X509Certificates.X509Certificate GetSignerCertificate()
+		{
+			return null;
+		}
+
 		internal abstract Type GetModuleType();
 
 		internal abstract ByteReader GetBlob(int blobIndex);
diff --git a/mcs/class/IKVM.Reflection/ParameterInfo.cs b/mcs/class/IKVM.Reflection/ParameterInfo.cs
index fa704ad764b..ca70d3346e5 100644
--- a/mcs/class/IKVM.Reflection/ParameterInfo.cs
+++ b/mcs/class/IKVM.Reflection/ParameterInfo.cs
@@ -99,6 +99,11 @@ namespace IKVM.Reflection
 			get { return (Attributes & ParameterAttributes.Optional) != 0; }
 		}
 
+		public bool HasDefaultValue
+		{
+			get { return (Attributes & ParameterAttributes.HasDefault) != 0; }
+		}
+
 		public bool IsDefined(Type attributeType, bool inherit)
 		{
 			return CustomAttributeData.__GetCustomAttributes(this, attributeType, inherit).Count != 0;
@@ -108,6 +113,16 @@ namespace IKVM.Reflection
 		{
 			return CustomAttributeData.__GetCustomAttributes(this, attributeType, inherit);
 		}
+
+		public IList<CustomAttributeData> GetCustomAttributesData()
+		{
+			return CustomAttributeData.GetCustomAttributes(this);
+		}
+
+		public IEnumerable<CustomAttributeData> CustomAttributes
+		{
+			get { return GetCustomAttributesData(); }
+		}
 	}
 
 	sealed class ParameterInfoWrapper : ParameterInfo
diff --git a/mcs/class/IKVM.Reflection/PropertyInfo.cs b/mcs/class/IKVM.Reflection/PropertyInfo.cs
index b05d07fb0c8..4d5ce9fb46d 100644
--- a/mcs/class/IKVM.Reflection/PropertyInfo.cs
+++ b/mcs/class/IKVM.Reflection/PropertyInfo.cs
@@ -148,6 +148,16 @@ namespace IKVM.Reflection
 			get { return (Attributes & PropertyAttributes.SpecialName) != 0; }
 		}
 
+		public MethodInfo GetMethod
+		{
+			get { return GetGetMethod(true); }
+		}
+
+		public MethodInfo SetMethod
+		{
+			get { return GetSetMethod(true); }
+		}
+
 		public MethodInfo GetGetMethod()
 		{
 			return GetGetMethod(false);
diff --git a/mcs/class/IKVM.Reflection/PropertySignature.cs b/mcs/class/IKVM.Reflection/PropertySignature.cs
index 9a4a5534d12..e6e0fee49b7 100644
--- a/mcs/class/IKVM.Reflection/PropertySignature.cs
+++ b/mcs/class/IKVM.Reflection/PropertySignature.cs
@@ -119,7 +119,7 @@ namespace IKVM.Reflection
 				flags |= VARARG;
 			}
 			bb.Write(flags);
-			bb.WriteCompressedInt(parameterTypes == null ? 0 : parameterTypes.Length);
+			bb.WriteCompressedUInt(parameterTypes == null ? 0 : parameterTypes.Length);
 			WriteCustomModifiers(module, bb, customModifiers.GetReturnTypeCustomModifiers());
 			WriteType(module, bb, propertyType);
 			if (parameterTypes != null)
@@ -170,7 +170,7 @@ namespace IKVM.Reflection
 			}
 			Type returnType;
 			Type[] parameterTypes;
-			int paramCount = br.ReadCompressedInt();
+			int paramCount = br.ReadCompressedUInt();
 			CustomModifiers[] mods = null;
 			PackedCustomModifiers.Pack(ref mods, 0, CustomModifiers.Read(module, br, context), paramCount + 1);
 			returnType = ReadRetType(module, br, context);
diff --git a/mcs/class/IKVM.Reflection/Reader/AssemblyReader.cs b/mcs/class/IKVM.Reflection/Reader/AssemblyReader.cs
index 0004862ee09..c64189eeb48 100644
--- a/mcs/class/IKVM.Reflection/Reader/AssemblyReader.cs
+++ b/mcs/class/IKVM.Reflection/Reader/AssemblyReader.cs
@@ -77,6 +77,37 @@ namespace IKVM.Reflection.Reader
 			}
 			name.HashAlgorithm = (AssemblyHashAlgorithm)rec.HashAlgId;
 			name.CodeBase = this.CodeBase;
+			PortableExecutableKinds peKind;
+			ImageFileMachine machine;
+			manifestModule.GetPEKind(out peKind, out machine);
+			switch (machine)
+			{
+				case ImageFileMachine.I386:
+					// FXBUG we copy the .NET bug that Preferred32Bit implies x86
+					if ((peKind & (PortableExecutableKinds.Required32Bit | PortableExecutableKinds.Preferred32Bit)) != 0)
+					{
+						name.ProcessorArchitecture = ProcessorArchitecture.X86;
+					}
+					else if ((rec.Flags & 0x70) == 0x70)
+					{
+						// it's a reference assembly
+						name.ProcessorArchitecture = ProcessorArchitecture.None;
+					}
+					else
+					{
+						name.ProcessorArchitecture = ProcessorArchitecture.MSIL;
+					}
+					break;
+				case ImageFileMachine.IA64:
+					name.ProcessorArchitecture = ProcessorArchitecture.IA64;
+					break;
+				case ImageFileMachine.AMD64:
+					name.ProcessorArchitecture = ProcessorArchitecture.Amd64;
+					break;
+				case ImageFileMachine.ARM:
+					name.ProcessorArchitecture = ProcessorArchitecture.Arm;
+					break;
+			}
 			name.RawFlags = (AssemblyNameFlags)rec.Flags;
 			return name;
 		}
@@ -199,13 +230,12 @@ namespace IKVM.Reflection.Reader
 			{
 				return externalModules[index];
 			}
-			// TODO add ModuleResolve event
-			string location = Path.Combine(Path.GetDirectoryName(this.location), manifestModule.GetString(manifestModule.File.records[index].Name));
-			return LoadModule(index, null, location);
+			return LoadModule(index, null, manifestModule.GetString(manifestModule.File.records[index].Name));
 		}
 
-		private Module LoadModule(int index, byte[] rawModule, string location)
+		private Module LoadModule(int index, byte[] rawModule, string name)
 		{
+			string location = name == null ? null : Path.Combine(Path.GetDirectoryName(this.location), name);
 			if ((manifestModule.File.records[index].Flags & ContainsNoMetaData) != 0)
 			{
 				return externalModules[index] = new ResourceModule(manifestModule, index, location);
@@ -214,7 +244,30 @@ namespace IKVM.Reflection.Reader
 			{
 				if (rawModule == null)
 				{
-					rawModule = File.ReadAllBytes(location);
+					try
+					{
+						rawModule = File.ReadAllBytes(location);
+					}
+					catch (FileNotFoundException)
+					{
+						if (resolvers != null)
+						{
+							ResolveEventArgs arg = new ResolveEventArgs(name, this);
+							foreach (ModuleResolveEventHandler resolver in resolvers)
+							{
+								Module module = resolver(this, arg);
+								if (module != null)
+								{
+									return module;
+								}
+							}
+						}
+						if (universe.MissingMemberResolution)
+						{
+							return externalModules[index] = new MissingModule(this);
+						}
+						throw;
+					}
 				}
 				return externalModules[index] = new ModuleReader(this, manifestModule.universe, new MemoryStream(rawModule), location);
 			}
@@ -259,9 +312,9 @@ namespace IKVM.Reflection.Reader
 			return manifestModule.__GetReferencedAssemblies();
 		}
 
-		public override AssemblyNameFlags __AssemblyFlags
+		protected override AssemblyNameFlags GetAssemblyFlags()
 		{
-			get { return (AssemblyNameFlags)manifestModule.AssemblyTable.records[0].Flags; }
+			return (AssemblyNameFlags)manifestModule.AssemblyTable.records[0].Flags;
 		}
 
 		internal string Name
diff --git a/mcs/class/IKVM.Reflection/Reader/Authenticode.cs b/mcs/class/IKVM.Reflection/Reader/Authenticode.cs
new file mode 100644
index 00000000000..76a78f30c2a
--- /dev/null
+++ b/mcs/class/IKVM.Reflection/Reader/Authenticode.cs
@@ -0,0 +1,15 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Security.Cryptography.X509Certificates;
+
+namespace IKVM.Reflection.Reader
+{
+	static class Authenticode
+	{
+		internal static X509Certificate GetSignerCertificate(Stream stream)
+		{
+			throw new NotSupportedException ("mcs");
+		}
+	}
+}
diff --git a/mcs/class/IKVM.Reflection/Reader/ByteReader.cs b/mcs/class/IKVM.Reflection/Reader/ByteReader.cs
index a82744fd9d1..e85328b7849 100644
--- a/mcs/class/IKVM.Reflection/Reader/ByteReader.cs
+++ b/mcs/class/IKVM.Reflection/Reader/ByteReader.cs
@@ -43,7 +43,7 @@ namespace IKVM.Reflection.Reader
 		internal static ByteReader FromBlob(byte[] blobHeap, int blob)
 		{
 			ByteReader br = new ByteReader(blobHeap, blob, 4);
-			int length = br.ReadCompressedInt();
+			int length = br.ReadCompressedUInt();
 			br.end = br.pos + length;
 			return br;
 		}
@@ -79,7 +79,7 @@ namespace IKVM.Reflection.Reader
 			return buf;
 		}
 
-		internal int ReadCompressedInt()
+		internal int ReadCompressedUInt()
 		{
 			byte b1 = ReadByte();
 			if (b1 <= 0x7F)
@@ -100,6 +100,29 @@ namespace IKVM.Reflection.Reader
 			}
 		}
 
+		internal int ReadCompressedInt()
+		{
+			byte b1 = PeekByte();
+			int value = ReadCompressedUInt();
+			if ((value & 1) == 0)
+			{
+				return value >> 1;
+			}
+			else
+			{
+				switch (b1 & 0xC0)
+				{
+					case 0:
+					case 0x40:
+						return (value >> 1) - 0x40;
+					case 0x80:
+						return (value >> 1) - 0x2000;
+					default:
+						return (value >> 1) - 0x10000000;
+				}
+			}
+		}
+
 		internal string ReadString()
 		{
 			if (PeekByte() == 0xFF)
@@ -107,7 +130,7 @@ namespace IKVM.Reflection.Reader
 				pos++;
 				return null;
 			}
-			int length = ReadCompressedInt();
+			int length = ReadCompressedUInt();
 			string str = Encoding.UTF8.GetString(buffer, pos, length);
 			pos += length;
 			return str;
diff --git a/mcs/class/IKVM.Reflection/Reader/ModuleReader.cs b/mcs/class/IKVM.Reflection/Reader/ModuleReader.cs
index 180e9689eef..c392033567d 100644
--- a/mcs/class/IKVM.Reflection/Reader/ModuleReader.cs
+++ b/mcs/class/IKVM.Reflection/Reader/ModuleReader.cs
@@ -79,26 +79,17 @@ namespace IKVM.Reflection.Reader
 
 		private sealed class LazyForwardedType
 		{
-			private readonly int assemblyRef;
+			private readonly int index;
 			private Type type;
 
-			internal LazyForwardedType(int assemblyRef)
+			internal LazyForwardedType(int index)
 			{
-				this.assemblyRef = assemblyRef;
+				this.index = index;
 			}
 
-			internal Type GetType(ModuleReader module, TypeName typeName)
+			internal Type GetType(ModuleReader module)
 			{
-				if (type == null)
-				{
-					Assembly asm = module.ResolveAssemblyRef(assemblyRef);
-					type = asm.ResolveType(typeName);
-					if (type == null)
-					{
-						throw new TypeLoadException(typeName.ToString());
-					}
-				}
-				return type;
+				return type ?? (type = module.ResolveExportedType(index));
 			}
 		}
 
@@ -198,10 +189,6 @@ namespace IKVM.Reflection.Reader
 					tables[i].Sorted = (Sorted & (1UL << i)) != 0;
 					tables[i].RowCount = br.ReadInt32();
 				}
-				else if (tables[i] != null)
-				{
-					tables[i].RowCount = 0;
-				}
 			}
 			MetadataReader mr = new MetadataReader(this, br.BaseStream, HeapSizes);
 			for (int i = 0; i < 64; i++)
@@ -275,7 +262,7 @@ namespace IKVM.Reflection.Reader
 					if (implementation >> 24 == AssemblyRefTable.Index)
 					{
 						TypeName typeName = GetTypeName(ExportedType.records[i].TypeNamespace, ExportedType.records[i].TypeName);
-						forwardedTypes.Add(typeName, new LazyForwardedType((implementation & 0xFFFFFF) - 1));
+						forwardedTypes.Add(typeName, new LazyForwardedType(i));
 					}
 				}
 			}
@@ -301,7 +288,7 @@ namespace IKVM.Reflection.Reader
 			return str;
 		}
 
-		private static int ReadCompressedInt(byte[] buffer, ref int offset)
+		private static int ReadCompressedUInt(byte[] buffer, ref int offset)
 		{
 			byte b1 = buffer[offset++];
 			if (b1 <= 0x7F)
@@ -324,7 +311,7 @@ namespace IKVM.Reflection.Reader
 
 		internal byte[] GetBlobCopy(int blobIndex)
 		{
-			int len = ReadCompressedInt(blobHeap, ref blobIndex);
+			int len = ReadCompressedUInt(blobHeap, ref blobIndex);
 			byte[] buf = new byte[len];
 			Buffer.BlockCopy(blobHeap, blobIndex, buf, 0, len);
 			return buf;
@@ -345,7 +332,7 @@ namespace IKVM.Reflection.Reader
 					throw TokenOutOfRangeException(metadataToken);
 				}
 				int index = metadataToken & 0xFFFFFF;
-				int len = ReadCompressedInt(userStringHeap, ref index) & ~1;
+				int len = ReadCompressedUInt(userStringHeap, ref index) & ~1;
 				StringBuilder sb = new StringBuilder(len / 2);
 				for (int i = 0; i < len; i += 2)
 				{
@@ -573,7 +560,7 @@ namespace IKVM.Reflection.Reader
 				LazyForwardedType fw;
 				if (forwardedTypes.TryGetValue(typeName, out fw))
 				{
-					return fw.GetType(this, typeName);
+					return fw.GetType(this);
 				}
 			}
 			return type;
@@ -593,7 +580,7 @@ namespace IKVM.Reflection.Reader
 			{
 				if (name.ToLowerInvariant() == lowerCaseName)
 				{
-					return forwardedTypes[name].GetType(this, name);
+					return forwardedTypes[name].GetType(this);
 				}
 			}
 			return null;
@@ -620,6 +607,10 @@ namespace IKVM.Reflection.Reader
 				case MethodDefTable.Index:
 				case MethodSpecTable.Index:
 					return ResolveMethod(metadataToken, genericTypeArguments, genericMethodArguments);
+				case TypeRefTable.Index:
+				case TypeDefTable.Index:
+				case TypeSpecTable.Index:
+					return ResolveType(metadataToken, genericTypeArguments, genericMethodArguments);
 				default:
 					throw TokenOutOfRangeException(metadataToken);
 			}
@@ -1097,14 +1088,18 @@ namespace IKVM.Reflection.Reader
 			TypeName typeName = GetTypeName(ExportedType.records[index].TypeNamespace, ExportedType.records[index].TypeName);
 			int implementation = ExportedType.records[index].Implementation;
 			int token = ExportedType.records[index].TypeDefId;
+			int flags = ExportedType.records[index].Flags;
 			switch (implementation >> 24)
 			{
 				case AssemblyRefTable.Index:
-					return ResolveAssemblyRef((implementation & 0xFFFFFF) - 1).ResolveType(typeName).SetMetadataTokenForMissing(token);
+					return ResolveAssemblyRef((implementation & 0xFFFFFF) - 1).ResolveType(typeName).SetMetadataTokenForMissing(token, flags);
 				case ExportedTypeTable.Index:
-					return ResolveExportedType((implementation & 0xFFFFFF) - 1).ResolveNestedType(typeName).SetMetadataTokenForMissing(token);
+					return ResolveExportedType((implementation & 0xFFFFFF) - 1).ResolveNestedType(typeName).SetMetadataTokenForMissing(token, flags);
+				case FileTable.Index:
+					Module module = assembly.GetModule(GetString(File.records[(implementation & 0xFFFFFF) - 1].Name));
+					return module.FindType(typeName) ?? module.universe.GetMissingTypeOrThrow(module, null, typeName).SetMetadataTokenForMissing(token, flags);
 				default:
-					throw new NotImplementedException();
+					throw new BadImageFormatException();
 			}
 		}
 
@@ -1265,5 +1260,10 @@ namespace IKVM.Reflection.Reader
 		{
 			get { return (cliHeader.Flags & CliHeader.COMIMAGE_FLAGS_NATIVE_ENTRYPOINT) == 0 ? (int)cliHeader.EntryPointToken : 0; }
 		}
+
+		public override System.Security.Cryptography.X509Certificates.X509Certificate GetSignerCertificate()
+		{
+			return Authenticode.GetSignerCertificate(stream);
+		}
 	}
 }
diff --git a/mcs/class/IKVM.Reflection/Reader/PEReader.cs b/mcs/class/IKVM.Reflection/Reader/PEReader.cs
index 50928c88e03..24152ce33a2 100644
--- a/mcs/class/IKVM.Reflection/Reader/PEReader.cs
+++ b/mcs/class/IKVM.Reflection/Reader/PEReader.cs
@@ -202,12 +202,6 @@ namespace IKVM.Reflection.Reader
 			VirtualAddress = br.ReadUInt32();
 			Size = br.ReadUInt32();
 		}
-
-		internal void Write(IKVM.Reflection.Writer.MetadataWriter mw)
-		{
-			mw.Write(VirtualAddress);
-			mw.Write(Size);
-		}
 	}
 
 	class SectionHeader
diff --git a/mcs/class/IKVM.Reflection/Signature.cs b/mcs/class/IKVM.Reflection/Signature.cs
index 68c3f10fd28..35c9a65b31e 100644
--- a/mcs/class/IKVM.Reflection/Signature.cs
+++ b/mcs/class/IKVM.Reflection/Signature.cs
@@ -98,7 +98,7 @@ namespace IKVM.Reflection
 			{
 				throw new BadImageFormatException();
 			}
-			int genArgCount = br.ReadCompressedInt();
+			int genArgCount = br.ReadCompressedUInt();
 			Type[] args = new Type[genArgCount];
 			CustomModifiers[] mods = null;
 			for (int i = 0; i < genArgCount; i++)
@@ -147,7 +147,7 @@ namespace IKVM.Reflection
 			{
 				throw new BadImageFormatException();
 			}
-			Type[] args = new Type[br.ReadCompressedInt()];
+			Type[] args = new Type[br.ReadCompressedUInt()];
 			for (int i = 0; i < args.Length; i++)
 			{
 				args[i] = ReadType(module, br, context);
@@ -155,9 +155,24 @@ namespace IKVM.Reflection
 			return args;
 		}
 
+		private static int[] ReadArraySizes(ByteReader br)
+		{
+			int num = br.ReadCompressedUInt();
+			if (num == 0)
+			{
+				return null;
+			}
+			int[] arr = new int[num];
+			for (int i = 0; i < num; i++)
+			{
+				arr[i] = br.ReadCompressedUInt();
+			}
+			return arr;
+		}
+
 		private static int[] ReadArrayBounds(ByteReader br)
 		{
-			int num = br.ReadCompressedInt();
+			int num = br.ReadCompressedUInt();
 			if (num == 0)
 			{
 				return null;
@@ -226,9 +241,9 @@ namespace IKVM.Reflection
 				case ELEMENT_TYPE_OBJECT:
 					return module.universe.System_Object;
 				case ELEMENT_TYPE_VAR:
-					return context.GetGenericTypeArgument(br.ReadCompressedInt());
+					return context.GetGenericTypeArgument(br.ReadCompressedUInt());
 				case ELEMENT_TYPE_MVAR:
-					return context.GetGenericMethodArgument(br.ReadCompressedInt());
+					return context.GetGenericMethodArgument(br.ReadCompressedUInt());
 				case ELEMENT_TYPE_GENERICINST:
 					return ReadGenericInst(module, br, context);
 				case ELEMENT_TYPE_SZARRAY:
@@ -236,7 +251,7 @@ namespace IKVM.Reflection
 					return ReadType(module, br, context).__MakeArrayType(mods);
 				case ELEMENT_TYPE_ARRAY:
 					mods = CustomModifiers.Read(module, br, context);
-					return ReadType(module, br, context).__MakeArrayType(br.ReadCompressedInt(), ReadArrayBounds(br), ReadArrayBounds(br), mods);
+					return ReadType(module, br, context).__MakeArrayType(br.ReadCompressedUInt(), ReadArraySizes(br), ReadArrayBounds(br), mods);
 				case ELEMENT_TYPE_PTR:
 					mods = CustomModifiers.Read(module, br, context);
 					return ReadTypeOrVoid(module, br, context).__MakePointerType(mods);
@@ -253,7 +268,7 @@ namespace IKVM.Reflection
 			{
 				throw new BadImageFormatException("Invalid local variable signature");
 			}
-			int count = br.ReadCompressedInt();
+			int count = br.ReadCompressedUInt();
 			for (int i = 0; i < count; i++)
 			{
 				if (br.PeekByte() == ELEMENT_TYPE_TYPEDBYREF)
@@ -336,15 +351,15 @@ namespace IKVM.Reflection
 					// LAMESPEC the Type production (23.2.12) doesn't include CustomMod* for arrays, but the verifier allows it and ildasm also supports it
 					WriteCustomModifiers(module, bb, type.__GetCustomModifiers());
 					WriteType(module, bb, type.GetElementType());
-					bb.WriteCompressedInt(rank);
+					bb.WriteCompressedUInt(rank);
 					int[] sizes = type.__GetArraySizes();
-					bb.WriteCompressedInt(sizes.Length);
+					bb.WriteCompressedUInt(sizes.Length);
 					for (int i = 0; i < sizes.Length; i++)
 					{
-						bb.WriteCompressedInt(sizes[i]);
+						bb.WriteCompressedUInt(sizes[i]);
 					}
 					int[] lobounds = type.__GetArrayLowerBounds();
-					bb.WriteCompressedInt(lobounds.Length);
+					bb.WriteCompressedUInt(lobounds.Length);
 					for (int i = 0; i < lobounds.Length; i++)
 					{
 						bb.WriteCompressedInt(lobounds[i]);
@@ -445,7 +460,7 @@ namespace IKVM.Reflection
 				{
 					bb.Write(ELEMENT_TYPE_VAR);
 				}
-				bb.WriteCompressedInt(type.GenericParameterPosition);
+				bb.WriteCompressedUInt(type.GenericParameterPosition);
 			}
 			else if (!type.__IsMissing && type.IsGenericType)
 			{
@@ -488,7 +503,7 @@ namespace IKVM.Reflection
 				bb.Write(ELEMENT_TYPE_CLASS);
 			}
 			bb.WriteTypeDefOrRefEncoded(module.GetTypeToken(type).Token);
-			bb.WriteCompressedInt(typeArguments.Length);
+			bb.WriteCompressedUInt(typeArguments.Length);
 			for (int i = 0; i < typeArguments.Length; i++)
 			{
 				WriteCustomModifiers(module, bb, customModifiers[i]);
@@ -507,7 +522,7 @@ namespace IKVM.Reflection
 
 		internal static Type ReadTypeDefOrRefEncoded(ModuleReader module, ByteReader br, IGenericContext context)
 		{
-			int encoded = br.ReadCompressedInt();
+			int encoded = br.ReadCompressedUInt();
 			switch (encoded & 3)
 			{
 				case 0:
@@ -564,7 +579,7 @@ namespace IKVM.Reflection
 			}
 			Type[] parameterTypes = sig.ParameterTypes;
 			Type[] optionalParameterTypes = sig.OptionalParameterTypes;
-			bb.WriteCompressedInt(parameterTypes.Length + optionalParameterTypes.Length);
+			bb.WriteCompressedUInt(parameterTypes.Length + optionalParameterTypes.Length);
 			WriteCustomModifiers(module, bb, sig.GetReturnTypeCustomModifiers());
 			WriteType(module, bb, sig.ReturnType);
 			int index = 0;
@@ -593,7 +608,7 @@ namespace IKVM.Reflection
 		internal static void WriteMethodSpec(ModuleBuilder module, ByteBuffer bb, Type[] genArgs)
 		{
 			bb.Write(GENERICINST);
-			bb.WriteCompressedInt(genArgs.Length);
+			bb.WriteCompressedUInt(genArgs.Length);
 			foreach (Type arg in genArgs)
 			{
 				WriteType(module, bb, arg);
@@ -604,7 +619,7 @@ namespace IKVM.Reflection
 		internal static Type[] ReadOptionalParameterTypes(ModuleReader module, ByteReader br, IGenericContext context, out CustomModifiers[] customModifiers)
 		{
 			br.ReadByte();
-			int paramCount = br.ReadCompressedInt();
+			int paramCount = br.ReadCompressedUInt();
 			CustomModifiers.Skip(br);
 			ReadRetType(module, br, context);
 			for (int i = 0; i < paramCount; i++)
@@ -647,7 +662,7 @@ namespace IKVM.Reflection
 			bb.Write(flags);
 			if (flags != FIELD)
 			{
-				bb.WriteCompressedInt(paramCount);
+				bb.WriteCompressedUInt(paramCount);
 			}
 			foreach (Type type in args)
 			{
diff --git a/mcs/class/IKVM.Reflection/Type.cs b/mcs/class/IKVM.Reflection/Type.cs
index bb0273c6ad0..6b9852ac327 100644
--- a/mcs/class/IKVM.Reflection/Type.cs
+++ b/mcs/class/IKVM.Reflection/Type.cs
@@ -302,6 +302,11 @@ namespace IKVM.Reflection
 			return ReferenceEquals(type, this) ? base.GetHashCode() : type.GetHashCode();
 		}
 
+		public Type[] GenericTypeArguments
+		{
+			get { return IsConstructedGenericType ? GetGenericArguments() : Type.EmptyTypes; }
+		}
+
 		public virtual Type[] GetGenericArguments()
 		{
 			return Type.EmptyTypes;
@@ -437,6 +442,87 @@ namespace IKVM.Reflection
 			throw new InvalidOperationException();
 		}
 
+		public string[] GetEnumNames()
+		{
+			if (!IsEnum)
+			{
+				throw new ArgumentException();
+			}
+			List<string> names = new List<string>();
+			foreach (FieldInfo field in __GetDeclaredFields())
+			{
+				if (field.IsLiteral)
+				{
+					names.Add(field.Name);
+				}
+			}
+			return names.ToArray();
+		}
+
+		public string GetEnumName(object value)
+		{
+			if (!IsEnum)
+			{
+				throw new ArgumentException();
+			}
+			if (value == null)
+			{
+				throw new ArgumentNullException();
+			}
+			try
+			{
+				value = Convert.ChangeType(value, GetTypeCode(GetEnumUnderlyingType()));
+			}
+			catch (FormatException)
+			{
+				throw new ArgumentException();
+			}
+			catch (OverflowException)
+			{
+				return null;
+			}
+			catch (InvalidCastException)
+			{
+				return null;
+			}
+			foreach (FieldInfo field in __GetDeclaredFields())
+			{
+				if (field.IsLiteral && field.GetRawConstantValue().Equals(value))
+				{
+					return field.Name;
+				}
+			}
+			return null;
+		}
+
+		public bool IsEnumDefined(object value)
+		{
+			if (value is string)
+			{
+				return Array.IndexOf(GetEnumNames(), value) != -1;
+			}
+			if (!IsEnum)
+			{
+				throw new ArgumentException();
+			}
+			if (value == null)
+			{
+				throw new ArgumentNullException();
+			}
+			if (System.Type.GetTypeCode(value.GetType()) != GetTypeCode(GetEnumUnderlyingType()))
+			{
+				throw new ArgumentException();
+			}
+			foreach (FieldInfo field in __GetDeclaredFields())
+			{
+				if (field.IsLiteral && field.GetRawConstantValue().Equals(value))
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+
 		public override string ToString()
 		{
 			return FullName;
@@ -1884,7 +1970,7 @@ namespace IKVM.Reflection
 			return new MissingProperty(this, name, sig);
 		}
 
-		internal virtual Type SetMetadataTokenForMissing(int token)
+		internal virtual Type SetMetadataTokenForMissing(int token, int flags)
 		{
 			return this;
 		}
@@ -1962,6 +2048,11 @@ namespace IKVM.Reflection
 			}
 			return type;
 		}
+
+		public virtual bool __IsTypeForwarder
+		{
+			get { return false; }
+		}
 	}
 
 	abstract class ElementHolderType : TypeInfo
@@ -2949,10 +3040,6 @@ namespace IKVM.Reflection
 
 	sealed class MarkerType : Type
 	{
-		// used by ILGenerator
-		internal static readonly Type Fault = new MarkerType();
-		internal static readonly Type Finally = new MarkerType();
-		internal static readonly Type Filter = new MarkerType();
 		// used by CustomModifiers and SignatureHelper
 		internal static readonly Type ModOpt = new MarkerType();
 		internal static readonly Type ModReq = new MarkerType();
diff --git a/mcs/class/IKVM.Reflection/Universe.cs b/mcs/class/IKVM.Reflection/Universe.cs
index 4999d3b4d0f..aa3b992065a 100644
--- a/mcs/class/IKVM.Reflection/Universe.cs
+++ b/mcs/class/IKVM.Reflection/Universe.cs
@@ -84,6 +84,7 @@ namespace IKVM.Reflection
 		EnableFunctionPointers = 1,
 		DisableFusion = 2,
 		DisablePseudoCustomAttributeRetrieval = 4,
+		DontProvideAutomaticDefaultConstructor = 8,
 	}
 
 	public sealed class Universe : IDisposable
@@ -99,6 +100,7 @@ namespace IKVM.Reflection
 		private readonly bool enableFunctionPointers;
 		private readonly bool useNativeFusion;
 		private readonly bool returnPseudoCustomAttributes;
+		private readonly bool automaticallyProvideDefaultConstructor;
 		private Type typeof_System_Object;
 		private Type typeof_System_ValueType;
 		private Type typeof_System_Enum;
@@ -168,6 +170,7 @@ namespace IKVM.Reflection
 			enableFunctionPointers = (options & UniverseOptions.EnableFunctionPointers) != 0;
 			useNativeFusion = (options & UniverseOptions.DisableFusion) == 0 && GetUseNativeFusion();
 			returnPseudoCustomAttributes = (options & UniverseOptions.DisablePseudoCustomAttributeRetrieval) == 0;
+			automaticallyProvideDefaultConstructor = (options & UniverseOptions.DontProvideAutomaticDefaultConstructor) == 0;
 		}
 
 		private static bool GetUseNativeFusion()
@@ -856,6 +859,16 @@ namespace IKVM.Reflection
 			return DefineDynamicAssemblyImpl(name, access, null, null, null, null);
 		}
 
+		public AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, IEnumerable<CustomAttributeBuilder> assemblyAttributes)
+		{
+			AssemblyBuilder ab = DefineDynamicAssembly(name, access);
+			foreach (CustomAttributeBuilder cab in assemblyAttributes)
+			{
+				ab.SetCustomAttribute(cab);
+			}
+			return ab;
+		}
+
 		public AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, string dir)
 		{
 			return DefineDynamicAssemblyImpl(name, access, dir, null, null, null);
@@ -1088,5 +1101,10 @@ namespace IKVM.Reflection
 		{
 			get { return returnPseudoCustomAttributes; }
 		}
+
+		internal bool AutomaticallyProvideDefaultConstructor
+		{
+			get { return automaticallyProvideDefaultConstructor; }
+		}
 	}
 }
diff --git a/mcs/class/IKVM.Reflection/Writer/ByteBuffer.cs b/mcs/class/IKVM.Reflection/Writer/ByteBuffer.cs
index e67bd70762a..d4592638079 100644
--- a/mcs/class/IKVM.Reflection/Writer/ByteBuffer.cs
+++ b/mcs/class/IKVM.Reflection/Writer/ByteBuffer.cs
@@ -105,7 +105,7 @@ namespace IKVM.Reflection.Writer
 		}
 
 		// return the number of bytes that the compressed int at the current position takes
-		internal int GetCompressedIntLength()
+		internal int GetCompressedUIntLength()
 		{
 			switch (buffer[pos] & 0xC0)
 			{
@@ -204,12 +204,12 @@ namespace IKVM.Reflection.Writer
 			else
 			{
 				byte[] buf = Encoding.UTF8.GetBytes(str);
-				WriteCompressedInt(buf.Length);
+				WriteCompressedUInt(buf.Length);
 				Write(buf);
 			}
 		}
 
-		internal void WriteCompressedInt(int value)
+		internal void WriteCompressedUInt(int value)
 		{
 			if (value <= 0x7F)
 			{
@@ -229,6 +229,33 @@ namespace IKVM.Reflection.Writer
 			}
 		}
 
+		internal void WriteCompressedInt(int value)
+		{
+			if (value >= 0)
+			{
+				WriteCompressedUInt(value << 1);
+			}
+			else if (value >= -64)
+			{
+				value = ((value << 1) & 0x7F) | 1;
+				Write((byte)value);
+			}
+			else if (value >= -8192)
+			{
+				value = ((value << 1) & 0x3FFF) | 1;
+				Write((byte)(0x80 | (value >> 8)));
+				Write((byte)value);
+			}
+			else
+			{
+				value = ((value << 1) & 0x1FFFFFFF) | 1;
+				Write((byte)(0xC0 | (value >> 24)));
+				Write((byte)(value >> 16));
+				Write((byte)(value >> 8));
+				Write((byte)value);
+			}
+		}
+
 		internal void Write(ByteBuffer bb)
 		{
 			if (pos + bb.Length > buffer.Length)
@@ -262,13 +289,13 @@ namespace IKVM.Reflection.Writer
 			switch (token >> 24)
 			{
 				case TypeDefTable.Index:
-					WriteCompressedInt((token & 0xFFFFFF) << 2 | 0);
+					WriteCompressedUInt((token & 0xFFFFFF) << 2 | 0);
 					break;
 				case TypeRefTable.Index:
-					WriteCompressedInt((token & 0xFFFFFF) << 2 | 1);
+					WriteCompressedUInt((token & 0xFFFFFF) << 2 | 1);
 					break;
 				case TypeSpecTable.Index:
-					WriteCompressedInt((token & 0xFFFFFF) << 2 | 2);
+					WriteCompressedUInt((token & 0xFFFFFF) << 2 | 2);
 					break;
 				default:
 					throw new InvalidOperationException();
diff --git a/mcs/class/IKVM.Reflection/Writer/Heaps.cs b/mcs/class/IKVM.Reflection/Writer/Heaps.cs
index 78a5d603efd..54beaa4a52e 100644
--- a/mcs/class/IKVM.Reflection/Writer/Heaps.cs
+++ b/mcs/class/IKVM.Reflection/Writer/Heaps.cs
@@ -235,7 +235,7 @@ namespace IKVM.Reflection.Writer
 			int offset;
 			if (!strings.TryGetValue(str, out offset))
 			{
-				int length = str.Length * 2 + 1 + MetadataWriter.GetCompressedIntLength(str.Length * 2 + 1);
+				int length = str.Length * 2 + 1 + MetadataWriter.GetCompressedUIntLength(str.Length * 2 + 1);
 				if (nextOffset + length > 0xFFFFFF)
 				{
 					throw new FileFormatLimitationExceededException("No logical space left to create more user strings.", FileFormatLimitationExceededException.META_E_STRINGSPACE_FULL);
@@ -258,7 +258,7 @@ namespace IKVM.Reflection.Writer
 			mw.Write((byte)0);
 			foreach (string str in list)
 			{
-				mw.WriteCompressedInt(str.Length * 2 + 1);
+				mw.WriteCompressedUInt(str.Length * 2 + 1);
 				byte hasSpecialChars = 0;
 				foreach (char ch in str)
 				{
@@ -335,7 +335,7 @@ namespace IKVM.Reflection.Writer
 			{
 				return 0;
 			}
-			int lenlen = MetadataWriter.GetCompressedIntLength(bblen);
+			int lenlen = MetadataWriter.GetCompressedUIntLength(bblen);
 			int hash = bb.Hash();
 			int index = (hash & 0x7FFFFFFF) % map.Length;
 			Key[] keys = map;
@@ -364,7 +364,7 @@ namespace IKVM.Reflection.Writer
 				index++;
 			}
 			int offset = buf.Position;
-			buf.WriteCompressedInt(bblen);
+			buf.WriteCompressedUInt(bblen);
 			buf.Write(bb);
 			keys[index].len = bblen;
 			keys[index].hash = hash;
diff --git a/mcs/class/IKVM.Reflection/Writer/MetadataWriter.cs b/mcs/class/IKVM.Reflection/Writer/MetadataWriter.cs
index be5ced78187..909b1c053a4 100644
--- a/mcs/class/IKVM.Reflection/Writer/MetadataWriter.cs
+++ b/mcs/class/IKVM.Reflection/Writer/MetadataWriter.cs
@@ -111,7 +111,7 @@ namespace IKVM.Reflection.Writer
 			stream.Write(buffer, 0, 8);
 		}
 
-		internal void WriteCompressedInt(int value)
+		internal void WriteCompressedUInt(int value)
 		{
 			if (value <= 0x7F)
 			{
@@ -131,7 +131,7 @@ namespace IKVM.Reflection.Writer
 			}
 		}
 
-		internal static int GetCompressedIntLength(int value)
+		internal static int GetCompressedUIntLength(int value)
 		{
 			if (value <= 0x7F)
 			{
diff --git a/mcs/class/IKVM.Reflection/Writer/ModuleWriter.cs b/mcs/class/IKVM.Reflection/Writer/ModuleWriter.cs
index 697ae974d99..6094283edcd 100644
--- a/mcs/class/IKVM.Reflection/Writer/ModuleWriter.cs
+++ b/mcs/class/IKVM.Reflection/Writer/ModuleWriter.cs
@@ -165,7 +165,7 @@ namespace IKVM.Reflection.Writer
 			{
 				cliHeader.Flags |= CliHeader.COMIMAGE_FLAGS_STRONGNAMESIGNED;
 			}
-			if (moduleBuilder.IsPseudoToken(entryPointToken))
+			if (ModuleBuilder.IsPseudoToken(entryPointToken))
 			{
 				entryPointToken = moduleBuilder.ResolvePseudoToken(entryPointToken);
 			}
diff --git a/mcs/class/IKVM.Reflection/reflect.build b/mcs/class/IKVM.Reflection/reflect.build
index f9c935bf22e..2689fbac642 100644
--- a/mcs/class/IKVM.Reflection/reflect.build
+++ b/mcs/class/IKVM.Reflection/reflect.build
@@ -56,6 +56,7 @@
                 <include name="StandAloneMethodSig.cs" />
                 <include name="StrongNameKeyPair.cs" />
                 <include name="Type.cs" />
+                <include name="TypeInfo.cs" />
                 <include name="TypeNameParser.cs" />
                 <include name="Universe.cs" />
                 <include name="Util.cs" />
@@ -65,6 +66,7 @@
                 <include name="Emit\CustomModifiersBuilder.cs" />
                 <include name="Emit\EnumBuilder.cs" />
                 <include name="Emit\Enums.cs" />
+                <include name="Emit\ExceptionHandler.cs" />
                 <include name="Emit\EventBuilder.cs" />
                 <include name="Emit\FieldBuilder.cs" />
                 <include name="Emit\ILGenerator.cs" />
@@ -86,6 +88,7 @@
                 <include name="Metadata\Tables.cs" />
                 <include name="Properties\AssemblyInfo.cs" />
                 <include name="Reader\AssemblyReader.cs" />
+                <include name="Reader\Authenticode.cs" />
                 <include name="Reader\ByteReader.cs" />
                 <include name="Reader\EventInfoImpl.cs" />
                 <include name="Reader\Field.cs" />
diff --git a/mcs/mcs/method.cs b/mcs/mcs/method.cs
index 8e3e8d1da7c..c0fe77b268e 100644
--- a/mcs/mcs/method.cs
+++ b/mcs/mcs/method.cs
@@ -1779,7 +1779,7 @@ namespace Mono.CSharp {
 			var token = ConstructorBuilder.GetToken ();
 			int t = token.Token;
 #if STATIC
-			if (token.IsPseudoToken)
+			if (ModuleBuilder.IsPseudoToken (t))
 				t = Module.Builder.ResolvePseudoToken (t);
 #endif
 
@@ -2120,7 +2120,7 @@ namespace Mono.CSharp {
 			var token = builder.GetToken ();
 			int t = token.Token;
 #if STATIC
-			if (token.IsPseudoToken)
+			if (ModuleBuilder.IsPseudoToken (t))
 				t = member.Module.Builder.ResolvePseudoToken (t);
 #endif
 
-- 
2.25.1