Minimal changes to zerolib to support more use cases. (#181)

* Minimal changes to zerolib to support more use cases.

* Adding .NET method to access command line args.

* Integrating Michal's feedback 2/22/24

src/zerolib/Internal/Startup.Efi.cs

@@ -43,7 +43,7 @@ internal static unsafe void InitializeCommandLineArgsW(int argc, char** argv)
             // argc and argv are garbage because EfiMain didn't pass any
         }
 
-        private static string[] GetMainMethodArguments()
+        internal static string[] GetMainMethodArguments()
         {
             return new string[0];
         }

src/zerolib/Internal/Startup.Unix.cs

@@ -33,7 +33,7 @@ internal static unsafe void InitializeCommandLineArgs(int argc, sbyte** argv)
             s_argv = argv;
         }
 
-        private static string[] GetMainMethodArguments()
+        internal static string[] GetMainMethodArguments()
         {
             string[] args = new string[s_argc - 1];
             for (int i = 1; i < s_argc; ++i)

src/zerolib/Internal/Startup.Windows.cs

@@ -29,7 +29,7 @@ internal static unsafe void InitializeCommandLineArgsW(int argc, char** argv)
             // argc and argv are a lie because CRT didn't start the process on Windows
         }
 
-        private static string[] GetMainMethodArguments()
+        internal static string[] GetMainMethodArguments()
         {
             int argc;
             char** argv = CommandLineToArgvW(GetCommandLineW(), &argc);

src/zerolib/Internal/Stubs.cs

@@ -46,7 +46,7 @@ internal unsafe struct MethodTable
 
 namespace Internal.Runtime.CompilerHelpers
 {
-    class ThrowHelpers
+    partial class ThrowHelpers
     {
         static void ThrowIndexOutOfRangeException() => Environment.FailFast(null);
         static void ThrowDivideByZeroException() => Environment.FailFast(null);

src/zerolib/System/Runtime/CompilerServices/ClassConstructorRunner.cs

@@ -20,7 +20,7 @@ namespace System.Runtime.CompilerServices
 {
     // A class responsible for running static constructors. The compiler will call into this
     // code to ensure static constructors run and that they only run once.
-    internal static class ClassConstructorRunner
+    internal static partial class ClassConstructorRunner
     {
         private static IntPtr CheckStaticClassConstructionReturnNonGCStaticBase(ref StaticClassConstructionContext context, IntPtr nonGcStaticBase)
         {

src/zerolib/System/Runtime/CompilerServices/CompilerAttributes.cs

@@ -47,4 +47,11 @@ public class CallConvStdcall { }
     public class CallConvSuppressGCTransition { }
     public class CallConvThiscall { }
     public class CallConvMemberFunction { }
+
+    public sealed class InlineArrayAttribute : Attribute
+    {
+        public InlineArrayAttribute(int size) { }
+    }
+
+    public sealed class ExtensionAttribute : Attribute { }
 }

src/zerolib/System/Runtime/CompilerServices/Unsafe.cs

@@ -30,5 +30,7 @@ public static unsafe partial class Unsafe
         public static extern T As<T>(object o) where T : class;
         [Intrinsic]
         public static extern void* AsPointer<T>(ref T value);
+        [Intrinsic]
+        public static extern ref T AsRef<T>(void* source);
     }
 }

src/zerolib/System/Runtime/InteropServices/InteropAttributes.cs

@@ -16,6 +16,8 @@
 
 namespace System.Runtime.InteropServices
 {
+    public enum UnmanagedType { }
+
     public enum CharSet
     {
         None = 1,

src/zerolib/System/Runtime/InteropServices/MemoryMarshal.cs

@@ -18,10 +18,18 @@
 
 namespace System.Runtime.InteropServices
 {
-    public static class MemoryMarshal
+    public static partial class MemoryMarshal
     {
         [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ref T GetArrayDataReference<T>(T[] array) => ref Unsafe.As<byte, T>(ref Unsafe.As<RawArrayData>(array).Data);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe static System.Span<T> CreateSpan<T>(ref T reference, int length)
+            => new System.Span<T>(Unsafe.AsPointer(ref reference), length);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe static System.ReadOnlySpan<T> CreateReadOnlySpan<T>(ref T reference, int length)
+            => new System.ReadOnlySpan<T>(Unsafe.AsPointer(ref reference), length);
     }
 }