Extend preinitialization interpreter to support calling string::Length (#78680)

* Support `callvirt` to a non-virtual method
* Support accessing string's fields

Author: MichalStrehovsky

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/TypePreinit.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 
 using ILCompiler.DependencyAnalysis;
 
@@ -402,6 +403,7 @@ private Status TryScanMethod(MethodIL methodIL, Value[] parameters, Stack<Method
                         break;
 
                     case ILOpcode.call:
+                    case ILOpcode.callvirt:
                         {
                             MethodDesc method = (MethodDesc)methodIL.GetObject(reader.ReadILToken());
                             MethodSignature methodSig = method.Signature;
@@ -427,6 +429,13 @@ private Status TryScanMethod(MethodIL methodIL, Value[] parameters, Stack<Method
                                 methodParams[i] = stack.PopIntoLocation(GetArgType(method, i));
                             }
 
+                            if (opcode == ILOpcode.callvirt)
+                            {
+                                // Only support non-virtual methods for now + we don't emulate NRE on null this
+                                if (method.IsVirtual || methodParams[0] == null)
+                                    return Status.Fail(methodIL.OwningMethod, opcode);
+                            }
+
                             Value retVal;
                             if (!method.IsIntrinsic || !TryHandleIntrinsicCall(method, methodParams, out retVal))
                             {
@@ -598,6 +607,11 @@ private Status TryScanMethod(MethodIL methodIL, Value[] parameters, Stack<Method
                                 return Status.Fail(methodIL.OwningMethod, opcode, "Reference field");
                             }
 
+                            if (field.FieldType.IsByRef)
+                            {
+                                return Status.Fail(methodIL.OwningMethod, opcode, "Byref field");
+                            }
+
                             var settableInstance = instance.Value as IHasInstanceFields;
                             if (settableInstance == null)
                             {
@@ -2259,28 +2273,65 @@ public override void WriteFieldData(ref ObjectDataBuilder builder, NodeFactory f
             public override ReferenceTypeValue ToForeignInstance(int baseInstructionCounter) => this;
         }
 
-        private sealed class StringInstance : ReferenceTypeValue
+        private sealed class StringInstance : ReferenceTypeValue, IHasInstanceFields
         {
-            private readonly string _value;
+            private readonly byte[] _value;
 
+            private string ValueAsString
+            {
+                get
+                {
+                    FieldDesc firstCharField = Type.GetField("_firstChar");
+                    int startOffset = firstCharField.Offset.AsInt;
+                    int length = _value.Length - startOffset - sizeof(char) /* terminating null */;
+                    return new string(MemoryMarshal.Cast<byte, char>(
+                        ((ReadOnlySpan<byte>)_value).Slice(startOffset, length)));
+                }
+            }
             public StringInstance(TypeDesc stringType, string value)
                 : base(stringType)
             {
-                _value = value;
+                _value = ConstructStringInstance(stringType, value);
+            }
+
+            private static byte[] ConstructStringInstance(TypeDesc stringType, ReadOnlySpan<char> value)
+            {
+                int pointerSize = stringType.Context.Target.PointerSize;
+                var bytes = new byte[
+                    pointerSize /* MethodTable */
+                    + sizeof(int) /* length */
+                    + (value.Length * sizeof(char)) /* bytes */
+                    + sizeof(char) /* null terminator */];
+
+                FieldDesc lengthField = stringType.GetField("_stringLength");
+                Debug.Assert(lengthField.FieldType.IsWellKnownType(WellKnownType.Int32)
+                    && lengthField.Offset.AsInt == pointerSize);
+                new FieldAccessor(bytes).SetField(lengthField, ValueTypeValue.FromInt32(value.Length));
+
+                FieldDesc firstCharField = stringType.GetField("_firstChar");
+                Debug.Assert(firstCharField.FieldType.IsWellKnownType(WellKnownType.Char)
+                    && firstCharField.Offset.AsInt == pointerSize + sizeof(int) /* length */);
+
+                value.CopyTo(MemoryMarshal.Cast<byte, char>(((Span<byte>)bytes).Slice(firstCharField.Offset.AsInt)));
+
+                return bytes;
             }
 
             public override void WriteFieldData(ref ObjectDataBuilder builder, NodeFactory factory)
             {
-                builder.EmitPointerReloc(factory.SerializedStringObject(_value));
+                builder.EmitPointerReloc(factory.SerializedStringObject(ValueAsString));
             }
 
             public override bool GetRawData(NodeFactory factory, out object data)
             {
-                data = factory.SerializedStringObject(_value);
+                data = factory.SerializedStringObject(ValueAsString);
                 return true;
             }
 
             public override ReferenceTypeValue ToForeignInstance(int baseInstructionCounter) => this;
+            Value IHasInstanceFields.GetField(FieldDesc field) => new FieldAccessor(_value).GetField(field);
+            void IHasInstanceFields.SetField(FieldDesc field, Value value) => ThrowHelper.ThrowInvalidProgramException();
+            ByRefValue IHasInstanceFields.GetFieldAddress(FieldDesc field) => new FieldAccessor(_value).GetFieldAddress(field);
         }
 
 #pragma warning disable CA1852

src/tests/nativeaot/SmokeTests/Preinitialization/Preinitialization.cs

@@ -45,6 +45,7 @@ private static int Main()
         TestGCInteraction.Run();
         TestDuplicatedFields.Run();
         TestInstanceDelegate.Run();
+        TestStringFields.Run();
 #else
         Console.WriteLine("Preinitialization is disabled in multimodule builds for now. Skipping test.");
 #endif
@@ -913,6 +914,37 @@ public static void Run()
     }
 }
 
+class TestStringFields
+{
+    class ClassAccessingLength
+    {
+        public static int Length = "Hello".Length;
+    }
+
+    class ClassAccessingNull
+    {
+        public static int Length;
+        static ClassAccessingNull()
+        {
+            string myNull = null;
+            try
+            {
+                Length = myNull.Length;
+            }
+            catch (Exception) { }
+        }
+    }
+
+    public static void Run()
+    {
+        Assert.IsPreinitialized(typeof(ClassAccessingLength));
+        Assert.AreEqual(5, ClassAccessingLength.Length);
+
+        Assert.IsLazyInitialized(typeof(ClassAccessingNull));
+        Assert.AreEqual(0, ClassAccessingNull.Length);
+    }
+}
+
 static class Assert
 {
     [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",