Implement small classes (#1259)

Signed-off-by: AnErrupTion <anerruption@disroot.org>

Author: AnErrupTion

Source/Mosa.TinyCoreLib/Internal/Impl.cs

@@ -0,0 +1,85 @@
+// Copyright (c) MOSA Project. Licensed under the New BSD License.
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Internal;
+
+internal static class Impl
+{
+	public static class Debug
+	{
+		public const string NoMessage = "No message";
+		public const string NoDetails = "No details";
+		public const string NoCategory = "No category";
+		public const string NoValue = "No value";
+		public const string FailText = "{0}\nDetails: {1}"; // {0} = Message, {1} = Details
+		public const string WriteText = "DEBUG ({0}): {1}"; // {0} = Category, {1} = Value/Message
+	}
+
+	public static class ConstructorInfo
+	{
+		public const string ConstructorName = ".ctor";
+		public const string TypeConstructorName = ".cctor";
+	}
+
+	public static class RuntimeHelpers
+	{
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern void InitializeArray(Array array, RuntimeFieldHandle fldHandle);
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern int GetHashCode(object o);
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public new static extern bool Equals(object o1, object o2);
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern T UnsafeCast<T>(object o) where T : class;
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern IEnumerable<Assembly> GetAssemblies();
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern object CreateInstance(Type type, params object[] args);
+
+		// The body of this function will be replaced by the EE with unsafe code
+		// See getILIntrinsicImplementation for how this happens.
+		[Intrinsic]
+		public static bool EnumEquals<T>(T x, T y) where T : Enum => x.Equals(y);
+
+		[Intrinsic]
+		public static bool IsReferenceOrContainsReferences<T>() => throw new InvalidOperationException();
+	}
+
+	public static class Bmi1
+	{
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern uint ResetLowestSetBit(uint value);
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern uint TrailingZeroCount(uint value);
+	}
+
+	public static class Lzcnt
+	{
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern uint LeadingZeroCount(uint value);
+	}
+
+	public static class Popcnt
+	{
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern uint PopCount(uint value);
+	}
+
+	public static class Object
+	{
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern Type GetType(object obj);
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern Type MemberwiseClone(object obj);
+	}
+}

Source/Mosa.TinyCoreLib/Internal/IntrinsicAttribute.cs

@@ -0,0 +1,9 @@
+// Copyright (c) MOSA Project. Licensed under the New BSD License.
+
+namespace System.Runtime.CompilerServices;
+
+/// <summary>
+/// Reserved by the compiler for tracking intrinsics.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Field, Inherited = false)]
+internal sealed class IntrinsicAttribute : Attribute;

Source/Mosa.TinyCoreLib/System.Buffers/MemoryHandle.cs

@@ -4,26 +4,33 @@ namespace System.Buffers;
 
 public struct MemoryHandle : IDisposable
 {
-	private object _dummy;
+	private unsafe void* pointer;
+	private GCHandle handle;
+	private IPinnable? pinnable;
 
-	private int _dummyPrimitive;
+	[CLSCompliant(false)] public unsafe void* Pointer => pointer;
 
 	[CLSCompliant(false)]
-	public unsafe void* Pointer
+	public unsafe MemoryHandle(void* pointer, GCHandle handle = default, IPinnable? pinnable = null)
 	{
-		get
-		{
-			throw null;
-		}
-	}
-
-	[CLSCompliant(false)]
-	public unsafe MemoryHandle(void* pointer, GCHandle handle = default(GCHandle), IPinnable? pinnable = null)
-	{
-		throw null;
+		this.pointer = pointer;
+		this.handle = handle;
+		this.pinnable = pinnable;
 	}
 
 	public void Dispose()
 	{
+		handle.Free();
+		
+		if (pinnable != null)
+		{
+			pinnable.Unpin();
+			pinnable = null;
+		}
+
+		unsafe
+		{
+			pointer = null;
+		}
 	}
 }