Merge pull request #44 from MichalStrehovsky/GCStatics

Add support for GC static fields

src/Common/src/TypeSystem/Common/FieldLayout.cs

@@ -153,6 +153,26 @@ out byteCount
  return algorithm._computedLayout;
  }
 
+ #region Runtime specific adjustements to the static field layout
+ // TODO: these should be factored out to make the static field layout algorithm more general purpose
+
+ private static void PrepareRuntimeSpecificStaticFieldLayout(TypeSystemContext context, ref ComputedStaticFieldLayout layout)
+ {
+ // GC statics start with a pointer to the "EEType" that signals the size and GCDesc to the GC
+ layout.GcStatics.Size = context.Target.PointerSize;
+ }
+
+ private static void FinalizeRuntimeSpecificStaticFieldLayout(TypeSystemContext context, ref ComputedStaticFieldLayout layout)
+ {
+ // If the size of GCStatics is equal to the size set in PrepareRuntimeSpecificStaticFieldLayout, we
+ // don't have any GC statics
+ if (layout.GcStatics.Size == context.Target.PointerSize)
+ {
+ layout.GcStatics.Size = 0;
+ }
+ }
+ #endregion
+
  public static unsafe ComputedStaticFieldLayout ComputeStaticFieldLayout(MetadataType type)
  {
  int numStaticFields = 0;
@@ -178,6 +198,8 @@ public static unsafe ComputedStaticFieldLayout ComputeStaticFieldLayout(Metadata
 
  result.Offsets = new FieldAndOffset[numStaticFields];
 
+ PrepareRuntimeSpecificStaticFieldLayout(type.Context, ref result);
+
  int index = 0;
 
  foreach (var field in type.GetFields())
@@ -206,6 +228,8 @@ public static unsafe ComputedStaticFieldLayout ComputeStaticFieldLayout(Metadata
  index++;
  }
 
+ FinalizeRuntimeSpecificStaticFieldLayout(type.Context, ref result);
+
  return result;
  }
 
@@ -538,6 +562,30 @@ public int NonGCStaticFieldAlignment
  }
  }
 
+ public int GCStaticFieldSize
+ {
+ get
+ {
+ if (!_fieldLayoutFlags.HasFlags(FieldLayoutFlags.HasStaticFieldLayout))
+ {
+ ComputeStaticFieldLayout();
+ }
+ return _staticBlockInfo == null ? 0 : _staticBlockInfo.GcStatics.Size;
+ }
+ }
+
+ public int GCStaticFieldAlignment
+ {
+ get
+ {
+ if (!_fieldLayoutFlags.HasFlags(FieldLayoutFlags.HasStaticFieldLayout))
+ {
+ ComputeStaticFieldLayout();
+ }
+ return _staticBlockInfo == null ? 0 : _staticBlockInfo.GcStatics.LargestAlignment;
+ }
+ }
+
  internal void ComputeInstanceFieldLayout()
  {
  var computedLayout = FieldLayoutAlgorithm.ComputeInstanceFieldLayout(this);

src/ILToNative.Compiler/src/Compiler/AsmWriter.cs

@@ -30,13 +30,18 @@ void OutputCode()
  Out.WriteLine();
 
  OutputReadyToHelpers();
-
  OutputEETypes();
 
  Out.WriteLine();
  Out.WriteLine(".data");
 
- OutputStatics();
+ Out.WriteLine();
+ Out.WriteLine("// Non-GC statics");
+ OutputNonGCStatics();
+
+ Out.WriteLine();
+ Out.WriteLine("// GC statics");
+ OutputGCStatics();
 
  Out.Dispose();
  }
@@ -248,6 +253,15 @@ void OutputReadyToHelpers()
  Out.WriteLine("ret");
  break;
 
+ case ReadyToRunHelperId.GetGCStaticBase:
+ Out.Write("leaq __GCStaticBase_");
+ Out.Write(NameMangler.GetMangledTypeName((TypeDesc)helper.Target));
+ Out.WriteLine("(%rip), %rax");
+ Out.WriteLine("mov (%rax), %rax");
+ Out.WriteLine("mov (%rax), %rax"); // RAX is now a GC pointer
+ Out.WriteLine("ret");
+ break;
+
  default:
  throw new NotImplementedException();
  }
@@ -296,7 +310,7 @@ void OutputEETypes()
  }
  }
 
- void OutputStatics()
+ void OutputNonGCStatics()
  {
  foreach (var t in _registeredTypes.Values)
  {
@@ -323,6 +337,73 @@ void OutputStatics()
  }
  }
 
+ void OutputGCStatics()
+ {
+ // Emit an array of GCHandle-sized elements for each type with GC statics
+ // Each element will be initially pointing at the pseudo EEType for the static.
+ // At runtime, it will be replaced by a GC handle to the GC-heap allocated object.
+
+ Out.WriteLine(".global __GCStaticRegionStart");
+ Out.WriteLine("__GCStaticRegionStart:");
+
+ foreach (var t in _registeredTypes.Values)
+ {
+ if (!t.IncludedInCompilation)
+ continue;
+
+ var type = t.Type as MetadataType;
+ if (type == null)
+ continue;
+
+ if (type.GCStaticFieldSize > 0)
+ {
+ Out.Write("__GCStaticBase_");
+ Out.Write(NameMangler.GetMangledTypeName(type));
+ Out.WriteLine(":");
+ Out.Write(".quad ");
+ Out.Write("__GCStaticEEType_");
+ Out.Write(NameMangler.GetMangledTypeName(type));
+ Out.WriteLine();
+ }
+ } 
+
+ Out.WriteLine(".global __GCStaticRegionEnd");
+ Out.WriteLine("__GCStaticRegionEnd:");
+
+ // Next emit a GCDesc followed by the size of the region described by the GCDesc
+ // for each type with GC statics.
+
+ // It should be possible to intern these at some point.
+
+ foreach (var t in _registeredTypes.Values)
+ {
+ if (!t.IncludedInCompilation)
+ continue;
+
+ var type = t.Type as MetadataType;
+ if (type == null)
+ continue;
+
+ if (type.GCStaticFieldSize > 0)
+ {
+ // numSeries
+ Out.WriteLine(".quad 0");
+
+ Out.Write("__GCStaticEEType_");
+ Out.Write(NameMangler.GetMangledTypeName(type));
+ Out.WriteLine(":");
+ Out.WriteLine(".int 0");
+ Out.Write(".int ");
+
+ // GC requires a minimum object size
+ int minimumObjectSize = type.Context.Target.PointerSize * 3;
+ int gcStaticSize = Math.Max(type.GCStaticFieldSize, minimumObjectSize);
+
+ Out.WriteLine(gcStaticSize);
+ }
+ }
+ }
+
  void OutputVirtualSlots(TypeDesc implType, TypeDesc declType)
  {
  var baseType = declType.BaseType;

src/ILToNative.Compiler/src/Compiler/JitHelper.cs

@@ -11,6 +11,7 @@ namespace ILToNative
  public enum JitHelperId
  {
  RngChkFail,
+ AssignRef,
  }
 
  class JitHelper
@@ -35,6 +36,9 @@ public string MangledName
  case JitHelperId.RngChkFail:
  return "__range_check_fail";
 
+ case JitHelperId.AssignRef:
+ return "WriteBarrier";
+
  default:
  throw new NotImplementedException();
  }

src/ILToNative.Compiler/src/Compiler/ReadyToRunHelper.cs

@@ -19,6 +19,7 @@ public enum ReadyToRunHelperId
  IsInstanceOf,
  CastClass,
  GetNonGCStaticBase,
+ GetGCStaticBase,
  }
 
  class ReadyToRunHelper
@@ -54,6 +55,8 @@ public string MangledName
  return "__CastClass_" + _compilation.NameMangler.GetMangledTypeName((TypeDesc)this.Target);
  case ReadyToRunHelperId.GetNonGCStaticBase:
  return "__GetNonGCStaticBase_" + _compilation.NameMangler.GetMangledTypeName((TypeDesc)this.Target);
+ case ReadyToRunHelperId.GetGCStaticBase:
+ return "__GetGCStaticBase_" + _compilation.NameMangler.GetMangledTypeName((TypeDesc)this.Target);
  default:
  throw new NotImplementedException();
  }

src/ILToNative.TypeSystem/tests/StaticFieldLayoutTests.cs

@@ -124,10 +124,10 @@ public void TestHasPointers()
  switch (field.Name)
  {
  case "string1":
- Assert.Equal(0, field.Offset);
+ Assert.Equal(8, field.Offset);
  break;
  case "class1":
- Assert.Equal(8, field.Offset);
+ Assert.Equal(16, field.Offset);
  break;
  default:
  throw new Exception(field.Name);
@@ -152,19 +152,19 @@ public void TestMixPointersAndNonPointers()
  switch (field.Name)
  {
  case "string1":
- Assert.Equal(0, field.Offset);
+ Assert.Equal(8, field.Offset);
  break;
  case "int1":
  Assert.Equal(0, field.Offset);
  break;
  case "class1":
- Assert.Equal(8, field.Offset);
+ Assert.Equal(16, field.Offset);
  break;
  case "int2":
  Assert.Equal(4, field.Offset);
  break;
  case "string2":
- Assert.Equal(16, field.Offset);
+ Assert.Equal(24, field.Offset);
  break;
  default:
  throw new Exception(field.Name);
@@ -193,7 +193,7 @@ public void TestEnsureInheritanceResetsStaticOffsets()
  Assert.Equal(0, field.Offset);
  break;
  case "string3":
- Assert.Equal(0, field.Offset);
+ Assert.Equal(8, field.Offset);
  break;
  default:
  throw new Exception(field.Name);

src/ILToNative/reproNative/main.cpp

@@ -81,11 +81,24 @@ void __reverse_pinvoke_return(ReversePInvokeFrame* pRevFrame)
 #endif // USE_MRT
 }
 
+extern "C" void* __GCStaticRegionStart;
+extern "C" void* __GCStaticRegionEnd;
+
 void __register_module(SimpleModuleHeader* pModule)
 {
 #if USE_MRT
  RhpRegisterSimpleModule(pModule);
 #endif // USE_MRT
+
+
+ // Initialize GC statics in the module
+ // TODO: emit a ModuleHeader and use it here
+
+ for (void** currentBlock = &__GCStaticRegionStart; currentBlock < &__GCStaticRegionEnd; currentBlock++)
+ {
+ Object* gcBlock = __allocate_object((MethodTable*)*currentBlock);
+ *currentBlock = CreateGlobalHandle(ObjectToOBJECTREF(gcBlock));
+ }
 }
 
 namespace mscorlib { namespace System { 
@@ -231,6 +244,38 @@ extern "C" Object * __allocate_array(size_t elements, MethodTable * pMT)
 #endif 
 }
 
+#if defined(_WIN64)
+// Card byte shift is different on 64bit.
+#define card_byte_shift 11
+#else
+#define card_byte_shift 10
+#endif
+
+#define card_byte(addr) (((size_t)(addr)) >> card_byte_shift)
+
+inline void ErectWriteBarrier(Object ** dst, Object * ref)
+{
+ // if the dst is outside of the heap (unboxed value classes) then we
+ // simply exit
+ if (((BYTE*)dst < g_lowest_address) || ((BYTE*)dst >= g_highest_address))
+ return;
+
+ if ((BYTE*)ref >= g_ephemeral_low && (BYTE*)ref < g_ephemeral_high)
+ {
+ // volatile is used here to prevent fetch of g_card_table from being reordered 
+ // with g_lowest/highest_address check above. See comment in code:gc_heap::grow_brick_card_tables.
+ BYTE* pCardByte = (BYTE *)*(volatile BYTE **)(&g_card_table) + card_byte((BYTE *)dst);
+ if (*pCardByte != 0xFF)
+ *pCardByte = 0xFF;
+ }
+}
+
+extern "C" void WriteBarrier(Object ** dst, Object * ref)
+{
+ *dst = ref;
+ ErectWriteBarrier(dst, ref);
+}
+
 void __throw_exception(void * pEx)
 {
  // TODO: Exception throwing

src/JitInterface/src/CorInfoImpl.cs

@@ -861,10 +861,14 @@ void getFieldInfo(IntPtr _this, ref CORINFO_RESOLVED_TOKEN pResolvedToken, CORIN
  pResult.helper = CorInfoHelpFunc.CORINFO_HELP_READYTORUN_STATIC_BASE;
 
  ReadyToRunHelperId helperId;
- if (field.IsThreadStatic || field.HasGCStaticBase)
+ if (field.IsThreadStatic)
  {
  throw new NotImplementedException();
  }
+ else if (field.HasGCStaticBase)
+ {
+ helperId = ReadyToRunHelperId.GetGCStaticBase;
+ }
  else
  {
  helperId = ReadyToRunHelperId.GetNonGCStaticBase;
@@ -1066,6 +1070,8 @@ uint getThreadTLSIndex(IntPtr _this, ref void* ppIndirection)
  {
  case CorInfoHelpFunc.CORINFO_HELP_RNGCHKFAIL:
  return (void*)ObjectToHandle(_compilation.GetJitHelper(JitHelperId.RngChkFail));
+ case CorInfoHelpFunc.CORINFO_HELP_ASSIGN_REF:
+ return (void*)ObjectToHandle(_compilation.GetJitHelper(JitHelperId.AssignRef));
  default:
  throw new NotImplementedException();
  }