Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

external/ikvm/reflect/Emit/ModuleBuilder.cs

@@ -1532,6 +1532,11 @@ namespace IKVM.Reflection.Emit
 			return Blobs.GetBlob(blobIndex);
 		}
 
+		internal sealed override Guid GetGuid(int guidIndex)
+		{
+			throw new NotImplementedException();
+		}
+
 		internal int GetSignatureBlobIndex(Signature sig)
 		{
 			ByteBuffer bb = new ByteBuffer(16);

external/ikvm/reflect/Fusion.cs

@@ -219,15 +219,17 @@ namespace IKVM.Reflection
 			}
 
 			bool fxUnified = false;
-			bool versionMatch = version1 == version2;
+
+			// build and revision numbers are ignored
+			bool fxVersionMatch = version1.Major == version2.Major && version1.Minor == version2.Minor;
 			if (IsFrameworkAssembly(name1))
 			{
-				fxUnified |= !versionMatch;
+				fxUnified |= !fxVersionMatch;
 				version1 = FrameworkVersion;
 			}
 			if (IsFrameworkAssembly(name2) && version2 < FrameworkVersionNext)
 			{
-				fxUnified |= !versionMatch;
+				fxUnified |= !fxVersionMatch;
 				version2 = FrameworkVersion;
 			}
 
@@ -274,7 +276,7 @@ namespace IKVM.Reflection
 						return false;
 					}
 				}
-				else if (!versionMatch || fxUnified)
+				else if (fxUnified || version1 != version2)
 				{
 					result = partial ? AssemblyComparisonResult.EquivalentPartialFXUnified : AssemblyComparisonResult.EquivalentFXUnified;
 					return true;

external/ikvm/reflect/Metadata/Tables.cs

@@ -2719,4 +2719,287 @@ namespace IKVM.Reflection.Metadata
 			Sort();
 		}
 	}
+
+	// Portable PDB
+	sealed class DocumentTable : Table<DocumentTable.Record>
+	{
+		internal const int Index = 0x30;
+
+		internal static Guid SHA1Guid = new Guid("ff1816ec-aa5e-4d10-87f7-6f4963833460");
+		internal static Guid CSharpGuid = new Guid("3f5162f8-07c6-11d3-9053-00c04fa302a1");
+
+		internal struct Record
+		{
+			internal int Name; // -> StringHeap
+			internal int HashAlgorithm; // -> GuidHeap
+			internal int Hash; // -> BlobHeap
+			internal int Language; // -> GuidHeap
+		}
+
+		internal override void Read(MetadataReader mr)
+		{
+			for (int i = 0; i < records.Length; i++)
+			{
+				records[i].Name = mr.ReadBlobIndex();
+				records[i].HashAlgorithm = mr.ReadGuidIndex();
+				records[i].Hash = mr.ReadBlobIndex();
+				records[i].Language = mr.ReadGuidIndex();
+			}
+		}
+
+		internal override void Write(MetadataWriter mw)
+		{
+			throw new NotImplementedException ();
+		}
+
+		protected override int GetRowSize(RowSizeCalc rsc)
+		{
+			return rsc
+				.WriteStringIndex()
+				.WriteGuidIndex()
+				.WriteBlobIndex()
+				.WriteGuidIndex()
+				.Value;
+		}
+	}
+
+	// Portable PDB
+	sealed class MethodDebugInformationTable : Table<MethodDebugInformationTable.Record>
+	{
+		internal const int Index = 0x31;
+
+		internal struct Record
+		{
+			internal int Document; // -> Document table
+			internal int SequencePoints; // -> BlobHeap
+		}
+
+		internal override void Read(MetadataReader mr)
+		{
+			for (int i = 0; i < records.Length; i++)
+			{
+				// FIXME: Token size
+				records[i].Document = mr.ReadInt16 ();
+				records[i].SequencePoints = mr.ReadBlobIndex();
+			}
+		}
+
+		internal override void Write(MetadataWriter mw)
+		{
+			throw new NotImplementedException ();
+		}
+
+		protected override int GetRowSize(RowSizeCalc rsc)
+		{
+			return rsc
+				.WriteBlobIndex()
+				.Value;
+		}
+	}
+
+	// Portable PDB
+	// FIXME: Sorted
+	sealed class LocalScopeTable : Table<LocalScopeTable.Record>
+	{
+		internal const int Index = 0x32;
+
+		internal struct Record
+		{
+			internal int Method;
+			internal int ImportScope;
+			internal int VariableList;
+			internal int ConstantList;
+			internal uint StartOffset;
+			internal uint Length;
+		}
+
+		internal override void Read(MetadataReader mr)
+		{
+			for (int i = 0; i < records.Length; i++)
+			{
+				// FIXME: Token sizes ?
+				records[i].Method = mr.ReadInt16();
+				records[i].ImportScope = mr.ReadInt16();
+				records[i].VariableList = mr.ReadInt16();
+				records[i].ConstantList = mr.ReadInt16();
+				records[i].StartOffset = (uint)mr.ReadInt32();
+				records[i].Length = (uint)mr.ReadInt32();
+			}
+		}
+
+		internal override void Write(MetadataWriter mw)
+		{
+			throw new NotImplementedException ();
+		}
+
+		protected override int GetRowSize(RowSizeCalc rsc)
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+	// Portable PDB
+	sealed class LocalVariableTable : Table<LocalVariableTable.Record>
+	{
+		internal const int Index = 0x33;
+
+		internal enum LocalVariableAttributes {
+			DebuggerHidden = 0x1
+		}
+
+		internal struct Record
+		{
+			internal int Attributes;
+			internal int Index;
+			internal int Name; // -> StringHeap
+		}
+
+		internal override void Read(MetadataReader mr)
+		{
+			for (int i = 0; i < records.Length; i++)
+			{
+				records[i].Attributes = mr.ReadInt16();
+				records[i].Index = mr.ReadInt16();
+				records[i].Name = mr.ReadStringIndex();
+			}
+		}
+
+		internal override void Write(MetadataWriter mw)
+		{
+			throw new NotImplementedException ();
+		}
+
+		protected override int GetRowSize(RowSizeCalc rsc)
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+	// Portable PDB
+	sealed class LocalConstantTable : Table<LocalConstantTable.Record>
+	{
+		internal const int Index = 0x34;
+
+		internal struct Record
+		{
+			internal int Name; // -> StringHeap
+			internal int Signature; // -> BlobHeap
+		}
+
+		internal override void Read(MetadataReader mr)
+		{
+			for (int i = 0; i < records.Length; i++)
+			{
+				records[i].Name = mr.ReadStringIndex();
+				records[i].Signature = mr.ReadBlobIndex();
+			}
+		}
+
+		internal override void Write(MetadataWriter mw)
+		{
+			throw new NotImplementedException ();
+		}
+
+		protected override int GetRowSize(RowSizeCalc rsc)
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+	// Portable PDB
+	sealed class ImportScopeTable : Table<ImportScopeTable.Record>
+	{
+		internal const int Index = 0x35;
+
+		internal struct Record
+		{
+			internal int Parent;
+			internal int Imports; // -> BlobHeap
+		}
+
+		internal override void Read(MetadataReader mr)
+		{
+			for (int i = 0; i < records.Length; i++)
+			{
+				// FIXME: Token size
+				records[i].Parent = mr.ReadUInt16();
+				records[i].Imports = mr.ReadBlobIndex();
+			}
+		}
+
+		internal override void Write(MetadataWriter mw)
+		{
+			throw new NotImplementedException ();
+		}
+
+		protected override int GetRowSize(RowSizeCalc rsc)
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+	// Portable PDB
+	sealed class StateMachineTable : Table<StateMachineTable.Record>
+	{
+		internal const int Index = 0x36;
+
+		internal struct Record
+		{
+			internal int MoveNextMethod;
+			internal int KickoffMethod;
+		}
+
+		internal override void Read(MetadataReader mr)
+		{
+			for (int i = 0; i < records.Length; i++)
+			{
+				records[i].MoveNextMethod = mr.ReadUInt16();
+				records[i].KickoffMethod = mr.ReadUInt16();
+			}
+		}
+
+		internal override void Write(MetadataWriter mw)
+		{
+			throw new NotImplementedException ();
+		}
+
+		protected override int GetRowSize(RowSizeCalc rsc)
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+	// Portable PDB
+	sealed class CustomDebugInformationTable : Table<CustomDebugInformationTable.Record>
+	{
+		internal const int Index = 0x37;
+
+		internal struct Record
+		{
+			internal int Parent;
+			internal int Kind; // -> GuidHeap
+			internal int Value; // -> BlobHeap
+		}
+
+		internal override void Read(MetadataReader mr)
+		{
+			for (int i = 0; i < records.Length; i++)
+			{
+				// FIXME: Token size
+				records[i].Parent = mr.ReadUInt16();
+				records[i].Kind = mr.ReadBlobIndex();
+				records[i].Value = mr.ReadBlobIndex();
+			}
+		}
+
+		internal override void Write(MetadataWriter mw)
+		{
+			throw new NotImplementedException ();
+		}
+
+		protected override int GetRowSize(RowSizeCalc rsc)
+		{
+			throw new NotImplementedException();
+		}
+	}
 }

external/ikvm/reflect/Module.cs

@@ -156,6 +156,14 @@ namespace IKVM.Reflection
 		internal readonly GenericParamTable GenericParam = new GenericParamTable();
 		internal readonly MethodSpecTable MethodSpec = new MethodSpecTable();
 		internal readonly GenericParamConstraintTable GenericParamConstraint = new GenericParamConstraintTable();
+		internal readonly DocumentTable Document = new DocumentTable();
+		internal readonly MethodDebugInformationTable MethodDebugInformation = new MethodDebugInformationTable();
+		internal readonly LocalScopeTable LocalScope = new LocalScopeTable();
+		internal readonly LocalVariableTable LocalVariable = new LocalVariableTable();
+		internal readonly LocalConstantTable LocalConstant = new LocalConstantTable();
+		internal readonly ImportScopeTable ImportScope = new ImportScopeTable();
+		internal readonly StateMachineTable StateMachine = new StateMachineTable();
+		internal readonly CustomDebugInformationTable CustomDebugInformation = new CustomDebugInformationTable();
 
 		protected Module(Universe universe)
 		{
@@ -204,6 +212,14 @@ namespace IKVM.Reflection
 			tables[GenericParamTable.Index] = GenericParam;
 			tables[MethodSpecTable.Index] = MethodSpec;
 			tables[GenericParamConstraintTable.Index] = GenericParamConstraint;
+			tables[DocumentTable.Index] = Document;
+			tables[MethodDebugInformationTable.Index] = MethodDebugInformation;
+			tables[LocalScopeTable.Index] = LocalScope;
+			tables[LocalVariableTable.Index] = LocalVariable;
+			tables[LocalConstantTable.Index] = LocalConstant;
+			tables[ImportScopeTable.Index] = ImportScope;
+			tables[StateMachineTable.Index] = StateMachine;
+			tables[CustomDebugInformationTable.Index] = CustomDebugInformation;
 			return tables;
 		}
 
@@ -552,6 +568,11 @@ namespace IKVM.Reflection
 			get { throw new NotSupportedException(); }
 		}
 
+		public virtual bool __IsMetadataOnly
+		{
+			get { throw new NotSupportedException(); }
+		}
+
 		public IEnumerable<CustomAttributeData> __EnumerateCustomAttributeTable()
 		{
 			List<CustomAttributeData> list = new List<CustomAttributeData>(CustomAttribute.RowCount);
@@ -594,6 +615,8 @@ namespace IKVM.Reflection
 
 		internal abstract ByteReader GetBlob(int blobIndex);
 
+		internal abstract Guid GetGuid(int guidIndex);
+
 		internal IList<CustomAttributeData> GetDeclarativeSecurity(int metadataToken)
 		{
 			List<CustomAttributeData> list = new List<CustomAttributeData>();
@@ -650,6 +673,11 @@ namespace IKVM.Reflection
 			throw InvalidOperationException();
 		}
 
+		internal sealed override Guid GetGuid(int guidIndex)
+		{
+			throw InvalidOperationException();
+		}
+
 		public sealed override AssemblyName[] __GetReferencedAssemblies()
 		{
 			throw NotSupportedException();

external/ikvm/reflect/Reader/ModuleReader.cs

@@ -52,6 +52,13 @@ namespace IKVM.Reflection.Reader
 		}
 	}
 
+	// FIXME: Put this somewhere else
+	class PdbStream {
+		public int EntryPoint { get; set; }
+		public ulong ReferencedTables { get; set; }
+		public int[] TableSizes { get; set; }
+	}
+
 	sealed class ModuleReader : Module
 	{
 		private readonly Stream stream;
@@ -78,6 +85,7 @@ namespace IKVM.Reflection.Reader
 		private Dictionary<int, string> strings = new Dictionary<int, string>();
 		private Dictionary<TypeName, Type> types = new Dictionary<TypeName, Type>();
 		private Dictionary<TypeName, LazyForwardedType> forwardedTypes = new Dictionary<TypeName, LazyForwardedType>();
+		private bool isMetadataOnly;
 
 		private sealed class LazyForwardedType
 		{
@@ -126,10 +134,23 @@ namespace IKVM.Reflection.Reader
 		private void Read(Stream stream, bool mapped)
 		{
 			BinaryReader br = new BinaryReader(stream);
-			peFile.Read(br, mapped);
-			stream.Seek(peFile.RvaToFileOffset(peFile.GetComDescriptorVirtualAddress()), SeekOrigin.Begin);
-			cliHeader.Read(br);
-			stream.Seek(peFile.RvaToFileOffset(cliHeader.MetaData.VirtualAddress), SeekOrigin.Begin);
+
+			long pos = stream.Position;
+			uint header = br.ReadUInt32();
+			stream.Seek(pos, SeekOrigin.Begin);
+
+			if (header == 0x424a5342)
+			{
+				// Naked metadata file (enc/portable pdb)
+				this.isMetadataOnly = true;
+			}
+			else
+			{
+				peFile.Read(br, mapped);
+				stream.Seek(peFile.RvaToFileOffset(peFile.GetComDescriptorVirtualAddress()), SeekOrigin.Begin);
+				cliHeader.Read(br);
+				stream.Seek(peFile.RvaToFileOffset(cliHeader.MetaData.VirtualAddress), SeekOrigin.Begin);
+			}
 			foreach (StreamHeader sh in ReadStreamHeaders(br, out imageRuntimeVersion))
 			{
 				switch (sh.Name)
@@ -149,9 +170,26 @@ namespace IKVM.Reflection.Reader
 						break;
 					case "#~":
 					case "#-":
-						stream.Seek(peFile.RvaToFileOffset(cliHeader.MetaData.VirtualAddress + sh.Offset), SeekOrigin.Begin);
+						if (isMetadataOnly)
+						{
+							stream.Seek(sh.Offset, SeekOrigin.Begin);
+						}
+						else
+						{
+							stream.Seek(peFile.RvaToFileOffset(cliHeader.MetaData.VirtualAddress + sh.Offset), SeekOrigin.Begin);
+						}
 						ReadTables(br);
 						break;
+				case "#Pdb":
+					var entryPoint = br.ReadInt32 ();
+					var referencedTables = br.ReadUInt64 ();
+					var tableSizes = new int [64];
+					for (int i = 0; i < 64; ++i) {
+						if ((referencedTables & ((ulong)1 << i)) != 0)
+							tableSizes [i] = (int)br.ReadUInt32 ();
+					}
+					/*pdbStream =*/ new PdbStream () { EntryPoint = entryPoint, ReferencedTables = referencedTables, TableSizes = tableSizes };
+					break;
 					default:
 						// we ignore unknown streams, because the CLR does so too
 						// (and some obfuscators add bogus streams)
@@ -204,6 +242,10 @@ namespace IKVM.Reflection.Reader
 			{
 				if ((Valid & (1UL << i)) != 0)
 				{
+					if (tables[i] == null)
+					{
+						throw new NotImplementedException ("Unknown table " + i);
+					}
 					tables[i].Sorted = (Sorted & (1UL << i)) != 0;
 					tables[i].RowCount = br.ReadInt32();
 				}
@@ -225,7 +267,14 @@ namespace IKVM.Reflection.Reader
 		private byte[] ReadHeap(Stream stream, uint offset, uint size)
 		{
 			byte[] buf = new byte[size];
-			stream.Seek(peFile.RvaToFileOffset(cliHeader.MetaData.VirtualAddress + offset), SeekOrigin.Begin);
+			if (isMetadataOnly)
+			{
+				stream.Seek(offset, SeekOrigin.Begin);
+			}
+			else
+			{
+				stream.Seek(peFile.RvaToFileOffset(cliHeader.MetaData.VirtualAddress + offset), SeekOrigin.Begin);
+			}
 			for (int pos = 0; pos < buf.Length; )
 			{
 				int read = stream.Read(buf, pos, buf.Length - pos);
@@ -349,6 +398,13 @@ namespace IKVM.Reflection.Reader
 			return ByteReader.FromBlob(blobHeap, blobIndex);
 		}
 
+		internal override Guid GetGuid(int guidIndex)
+		{
+			byte[] buf = new byte[16];
+			Buffer.BlockCopy(guidHeap, 16 * (guidIndex - 1), buf, 0, 16);
+			return new Guid(buf);
+		}
+
 		public override string ResolveString(int metadataToken)
 		{
 			string str;
@@ -1149,8 +1205,17 @@ namespace IKVM.Reflection.Reader
 			get { return metadataStreamVersion; }
 		}
 
+		public override bool __IsMetadataOnly
+		{
+			get { return isMetadataOnly; }
+		}
+
 		public override void __GetDataDirectoryEntry(int index, out int rva, out int length)
 		{
+			if (isMetadataOnly)
+			{
+				throw new NotSupportedException();
+			}
 			peFile.GetDataDirectoryEntry(index, out rva, out length);
 		}
 

external/ikvm/reflect/Universe.cs

@@ -136,6 +136,7 @@ namespace IKVM.Reflection
 		DisableWindowsRuntimeProjection = 64,
 		DecodeVersionInfoAttributeBlobs = 128,
 		DeterministicOutput = 256,
+		DisableDefaultAssembliesLookup = 512,
 	}
 
 	public sealed class Universe : IDisposable
@@ -676,7 +677,7 @@ namespace IKVM.Reflection
 		private Assembly GetLoadedAssembly(string refname)
 		{
 			Assembly asm;
-			if (!assembliesByName.TryGetValue(refname, out asm))
+			if (!assembliesByName.TryGetValue(refname, out asm) && (options & UniverseOptions.DisableDefaultAssembliesLookup) == 0)
 			{
 				string simpleName = GetSimpleAssemblyName(refname);
 				for (int i = 0; i < assemblies.Count; i++)