Implement helper to get the non-GC static base

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/Target_X86/X86Emitter.cs

@@ -18,6 +18,14 @@ public X86Emitter(NodeFactory factory, bool relocsOnly)
  public ObjectDataBuilder Builder;
  public TargetRegisterMap TargetRegister;
 
+ public void EmitCMP(ref AddrMode addrMode, sbyte immediate)
+ {
+ if (addrMode.Size == AddrModeSize.Int16)
+ Builder.EmitByte(0x66);
+ EmitIndirInstruction((byte)((addrMode.Size != AddrModeSize.Int8) ? 0x83 : 0x80), 0x7, ref addrMode);
+ Builder.EmitByte((byte)immediate);
+ }
+
  public void EmitADD(ref AddrMode addrMode, sbyte immediate)
  {
  if (addrMode.Size == AddrModeSize.Int16)
@@ -76,7 +84,13 @@ public void EmitPUSH(ISymbolNode node)
  }
  }
 
- public void EmitMOV(Register register, ISymbolNode node)
+ public void EmitMOV(Register regDst, Register regSrc)
+ {
+ Builder.EmitByte(0x8B);
+ Builder.EmitByte((byte)(0xC0 | (((int)regDst & 0x07) << 3) | (((int)regSrc & 0x07))));
+ }
+
+ public void EmitMOV(Register register, ISymbolNode node, int delta = 0)
  {
  if (node.RepresentsIndirectionCell)
  {
@@ -89,14 +103,29 @@ public void EmitMOV(Register register, ISymbolNode node)
  // mov register, immediate
  Builder.EmitByte((byte)(0xB8 + (byte)register));
  }
- Builder.EmitReloc(node, RelocType.IMAGE_REL_BASED_HIGHLOW);
+ Builder.EmitReloc(node, RelocType.IMAGE_REL_BASED_HIGHLOW, delta);
  }
 
  public void EmitINT3()
  {
  Builder.EmitByte(0xCC);
  }
 
+ public void EmitRET()
+ {
+ Builder.EmitByte(0xC3);
+ }
+
+ public void EmitRETIfEqual()
+ {
+ // jne @+1
+ Builder.EmitByte(0x75);
+ Builder.EmitByte(0x01);
+
+ // ret
+ Builder.EmitByte(0xC3);
+ }
+
  private bool InSignedByteRange(int i)
  {
  return i == (int)(sbyte)i;

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/Target_X86/X86ReadyToRunHelperNode.cs

@@ -3,22 +3,75 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Generic;
-using System.Diagnostics;
+
 using ILCompiler.DependencyAnalysis.X86;
+
 using Internal.TypeSystem;
-using ILCompiler;
 
 namespace ILCompiler.DependencyAnalysis
 {
  /// <summary>
- /// X64 specific portions of ReadyToRunHelperNode
+ /// X86 specific portions of ReadyToRunHelperNode
  /// </summary>
  public partial class ReadyToRunHelperNode
  {
  protected override void EmitCode(NodeFactory factory, ref X86Emitter encoder, bool relocsOnly)
  {
- throw new NotImplementedException();
+ switch (Id)
+ {
+ case ReadyToRunHelperId.VirtualCall:
+ {
+ throw new NotImplementedException();
+ }
+
+ case ReadyToRunHelperId.GetNonGCStaticBase:
+ {
+ MetadataType target = (MetadataType)Target;
+ bool hasLazyStaticConstructor = factory.TypeSystemContext.HasLazyStaticConstructor(target);
+ encoder.EmitMOV(encoder.TargetRegister.Result, factory.TypeNonGCStaticsSymbol(target));
+
+ if (!hasLazyStaticConstructor)
+ {
+ encoder.EmitRET();
+ }
+ else
+ {
+ // We need to trigger the cctor before returning the base. It is stored at the beginning of the non-GC statics region.
+ encoder.EmitMOV(encoder.TargetRegister.Arg0, factory.TypeNonGCStaticsSymbol(target), -NonGCStaticsNode.GetClassConstructorContextStorageSize(factory.Target, target));
+
+ AddrMode initialized = new AddrMode(encoder.TargetRegister.Arg0, null, factory.Target.PointerSize, 0, AddrModeSize.Int32);
+ encoder.EmitCMP(ref initialized, 1);
+ encoder.EmitRETIfEqual();
+
+ encoder.EmitMOV(encoder.TargetRegister.Arg1, encoder.TargetRegister.Result);
+ encoder.EmitJMP(factory.HelperEntrypoint(HelperEntrypoint.EnsureClassConstructorRunAndReturnNonGCStaticBase));
+ }
+ }
+ break;
+
+ case ReadyToRunHelperId.GetThreadStaticBase:
+ {
+ throw new NotImplementedException();
+ }
+
+ case ReadyToRunHelperId.GetGCStaticBase:
+ {
+ throw new NotImplementedException();
+ }
+
+ case ReadyToRunHelperId.DelegateCtor:
+ {
+ throw new NotImplementedException();
+ }
+
+ case ReadyToRunHelperId.ResolveVirtualFunction:
+ {
+ throw new NotImplementedException();
+ }
+
+ default:
+ throw new NotImplementedException();
+ }
  }
  }
 }