modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/Imported/Bartok/runtime/shared/GCs/Barrier.cs

4564 lines
177 KiB
C#
Raw Permalink Normal View History

RDK 2.0
2008-11-17 18:29:00 -05:00
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
/*******************************************************************/
/* WARNING */
/* This file should be identical in the Bartok and Singularity */
/* depots. Master copy resides in Bartok Depot. Changes should be */
/* made to Bartok Depot and propagated to Singularity Depot. */
/*******************************************************************/
namespace System.GCs
{
using Microsoft.Bartok.Runtime;
using System.Runtime.CompilerServices;
using System.Threading;
//[CCtorIsRunDuringStartup]
//[NoBarriers]
[NoCCtor]
internal abstract unsafe class Barrier
{
[TrustedNonNull]
[NoBarriers]
protected internal static Barrier installedBarrier;
[TrustedNonNull]
private static CopyFieldsVisitor copyFieldsVisitor;
[TrustedNonNull]
private static ZeroFieldsVisitor zeroFieldsVisitor;
[TrustedNonNull]
private static SlowCopyFieldsVisitor slowCopyFieldsVisitor;
[TrustedNonNull]
private static SlowZeroFieldsVisitor slowZeroFieldsVisitor;
[NoBarriers]
[NoHeapAllocation]
internal static void PreInitialize()
{
#if !SINGULARITY || CONCURRENT_MS_COLLECTOR
if (GC.wbType == WBType.CMS) {
// We need a write barrier even if we haven't set up enough of the memory
// system to support allocating from bootstrap memory yet.
installedBarrier = WriteBarrierCMS.MakeEarlyInstance();
}
#endif
}
[NoBarriers]
[PreInitRefCounts]
internal static void Initialize()
{
switch (GC.wbType) {
#if !SINGULARITY || MARK_SWEEP_COLLECTOR || NULL_COLLECTOR
case WBType.noWB: {
EmptyWriteBarrier.Initialize();
installedBarrier = EmptyWriteBarrier.instance;
break;
}
#endif
#if !SINGULARITY || SEMISPACE_COLLECTOR || SLIDING_COLLECTOR || ADAPTIVE_COPYING_COLLECTOR
case WBType.Generational: {
GenerationalWriteBarrier.Initialize();
installedBarrier = GenerationalWriteBarrier.instance;
break;
}
#endif
#if !SINGULARITY || CONCURRENT_MS_COLLECTOR
case WBType.CMS: {
WriteBarrierCMS.Initialize();
installedBarrier = WriteBarrierCMS.instance;
break;
}
#endif
#if !SINGULARITY || ATOMIC_RC_COLLECTOR
case WBType.ARC: {
AtomicRCWriteBarrier.Initialize();
installedBarrier = AtomicRCWriteBarrier.instance;
break;
}
#endif
#if !SINGULARITY || SEMISPACE_COLLECTOR || SLIDING_COLLECTOR || ADAPTIVE_COPYING_COLLECTOR
case WBType.AllCards: {
AllCardsWriteBarrier.Initialize();
installedBarrier = AllCardsWriteBarrier.instance;
break;
}
#endif
#if !SINGULARITY
case WBType.ExpandingCoCo: {
ExpandingCoCoBarrier.Initialize();
installedBarrier = ExpandingCoCoBarrier.instance;
break;
}
case WBType.ProbabilisticCoCo: {
ProbabilisticCoCoBarrier.Initialize();
installedBarrier = ProbabilisticCoCoBarrier.instance;
break;
}
case WBType.AbortingCoCo: {
AbortingCoCoBarrier.Initialize();
installedBarrier = AbortingCoCoBarrier.instance;
break;
}
case WBType.BrooksTest: {
BrooksBarrierTest.Initialize();
installedBarrier = BrooksBarrierTest.instance;
break;
}
case WBType.BrooksCMSTest: {
BrooksCMSBarrierTest.Initialize();
installedBarrier = BrooksCMSBarrierTest.instance;
break;
}
#endif
default: {
VTable.NotReached("Unknown write barrier type: "+GC.wbType);
break;
}
}
// copyFieldsVisitor = new CopyFieldsVisitor();
Barrier.copyFieldsVisitor = (CopyFieldsVisitor)
BootstrapMemory.Allocate(typeof(CopyFieldsVisitor));
// zeroFieldsVisitor = new ZeroFieldsVisitor();
Barrier.zeroFieldsVisitor = (ZeroFieldsVisitor)
BootstrapMemory.Allocate(typeof(ZeroFieldsVisitor));
// slowCopyFieldsVisitor = new SlowCopyFieldsVisitor();
Barrier.slowCopyFieldsVisitor = (SlowCopyFieldsVisitor)
BootstrapMemory.Allocate(typeof(SlowCopyFieldsVisitor));
// slowZeroFieldsVisitor = new SlowZeroFieldsVisitor();
Barrier.slowZeroFieldsVisitor = (SlowZeroFieldsVisitor)
BootstrapMemory.Allocate(typeof(SlowZeroFieldsVisitor));
}
// NOTE: this code uses ForceInline instead of Inline to indicate that
// inlining should occur even if the caller is huge. In general, this
// attribute should be used with great care. DO NOT USE IT ELSEWHERE IN
// THE RUNTIME UNLESS YOU ARE WILLING TO DOCUMENT YOUR USE IN
// IrSimpleInliner.cs AND Attributes.cs! AND NEVER USE IT IN
// APPLICATION OR OS CODE!
//////////////////////// StoreIndirectImpl /////////////////////
[ForceInline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImplByRef(ref Object location,
Object value,
int mask)
{
this.WriteImplByRef(ref location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImplByRef(ref float location,
float value,
int mask)
{
this.WriteImplByRef(ref location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImplByRef(ref double location,
double value,
int mask)
{
this.WriteImplByRef(ref location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImplByRef(ref byte location,
byte value,
int mask)
{
this.WriteImplByRef(ref location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImplByRef(ref ushort location,
ushort value,
int mask)
{
this.WriteImplByRef(ref location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImplByRef(ref uint location,
uint value,
int mask)
{
this.WriteImplByRef(ref location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImplByRef(ref ulong location,
ulong value,
int mask)
{
this.WriteImplByRef(ref location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImplByRef(ref UIntPtr location,
UIntPtr value,
int mask)
{
this.WriteImplByRef(ref location, value, mask);
}
//////////////////////// StoreIndirectImpl to ptr /////////////////////
[ForceInline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImpl(UIntPtr* location,
Object value,
int mask)
{
this.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImpl(float* location,
float value,
int mask)
{
this.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImpl(double* location,
double value,
int mask)
{
this.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImpl(byte* location,
byte value,
int mask)
{
this.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImpl(ushort* location,
ushort value,
int mask)
{
this.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImpl(uint* location,
uint value,
int mask)
{
this.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImpl(ulong* location,
ulong value,
int mask)
{
this.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreIndirectImpl(UIntPtr* location,
UIntPtr value,
int mask)
{
this.WriteImpl(location, value, mask);
}
//////////////////////// LoadIndirectImpl from ptr /////////////////////
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual Object LoadObjIndirectImpl(UIntPtr* location,
int mask)
{
return this.ReadObjImpl(location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual float LoadIndirectImpl(float* location,
int mask)
{
return this.ReadImpl(location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual double LoadIndirectImpl(double* location,
int mask)
{
return this.ReadImpl(location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual byte LoadIndirectImpl(byte* location,
int mask)
{
return this.ReadImpl(location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual ushort LoadIndirectImpl(ushort* location,
int mask)
{
return this.ReadImpl(location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual uint LoadIndirectImpl(uint* location,
int mask)
{
return this.ReadImpl(location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual ulong LoadIndirectImpl(ulong* location,
int mask)
{
return this.ReadImpl(location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual UIntPtr LoadIndirectImpl(UIntPtr* location,
int mask)
{
return this.ReadImpl(location, mask);
}
//////////////////////// LoadIndirectImpl /////////////////////
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual Object LoadIndirectImplByRef(ref Object location,
int mask)
{
return this.ReadImplByRef(ref location, mask);
}
[Inline]
[NoBarriers]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual float LoadIndirectImplByRef(ref float location,
int mask)
{
return this.ReadImplByRef(ref location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual double LoadIndirectImplByRef(ref double location,
int mask)
{
return this.ReadImplByRef(ref location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual byte LoadIndirectImplByRef(ref byte location,
int mask)
{
return this.ReadImplByRef(ref location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual ushort LoadIndirectImplByRef(ref ushort location,
int mask)
{
return this.ReadImplByRef(ref location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual uint LoadIndirectImplByRef(ref uint location,
int mask)
{
return this.ReadImplByRef(ref location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual ulong LoadIndirectImplByRef(ref ulong location,
int mask)
{
return this.ReadImplByRef(ref location, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual UIntPtr LoadIndirectImplByRef(ref UIntPtr location,
int mask)
{
return this.ReadImplByRef(ref location, mask);
}
/////////////////////// StoreObjectFieldImpl ///////////////////
[ForceInline]
[NoBarriers]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual void StoreObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
Object value,
int mask)
{
this.WriteImpl(obj, fieldOffset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
float value,
int mask)
{
this.WriteImpl(obj, fieldOffset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
double value,
int mask)
{
this.WriteImpl(obj, fieldOffset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
byte value,
int mask)
{
this.WriteImpl(obj, fieldOffset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
ushort value,
int mask)
{
this.WriteImpl(obj, fieldOffset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
uint value,
int mask)
{
this.WriteImpl(obj, fieldOffset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
ulong value,
int mask)
{
this.WriteImpl(obj, fieldOffset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
UIntPtr value,
int mask)
{
this.WriteImpl(obj, fieldOffset, value, mask);
}
/////////////////////// LoadObjectFieldImpl ///////////////////
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual Object LoadObjObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
int mask)
{
return this.ReadObjImpl(obj, fieldOffset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual float LoadFloatObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
int mask)
{
return this.ReadFloatImpl(obj, fieldOffset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual double LoadDoubleObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
int mask)
{
return this.ReadDoubleImpl(obj, fieldOffset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual byte LoadByteObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
int mask)
{
return this.ReadByteImpl(obj, fieldOffset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual ushort LoadUShortObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
int mask)
{
return this.ReadUShortImpl(obj, fieldOffset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual uint LoadUIntObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
int mask)
{
return this.ReadUIntImpl(obj, fieldOffset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual ulong LoadULongObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
int mask)
{
return this.ReadULongImpl(obj, fieldOffset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
UIntPtr LoadUIntPtrObjectFieldImpl(Object obj,
UIntPtr fieldOffset,
int mask)
{
return this.ReadUIntPtrImpl(obj, fieldOffset, mask);
}
////////////////////// StoreStructFieldImpl ////////////////////
[ForceInline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
Object value,
int mask)
{
UIntPtr *fieldPtr = (UIntPtr *) (structPtr + fieldOffset);
this.WriteImpl(fieldPtr, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
float value,
int mask)
{
float *fieldPtr = (float *) (structPtr + fieldOffset);
this.WriteImpl(fieldPtr, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
double value,
int mask)
{
double *fieldPtr = (double *) (structPtr + fieldOffset);
this.WriteImpl(fieldPtr, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
byte value,
int mask)
{
byte *fieldPtr = (byte *) (structPtr + fieldOffset);
this.WriteImpl(fieldPtr, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
ushort value,
int mask)
{
ushort *fieldPtr = (ushort *) (structPtr + fieldOffset);
this.WriteImpl(fieldPtr, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
uint value,
int mask)
{
uint *fieldPtr = (uint *) (structPtr + fieldOffset);
this.WriteImpl(fieldPtr, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
ulong value,
int mask)
{
ulong *fieldPtr = (ulong *) (structPtr + fieldOffset);
this.WriteImpl(fieldPtr, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
UIntPtr value,
int mask)
{
UIntPtr *fieldPtr = (UIntPtr *) (structPtr + fieldOffset);
this.WriteImpl(fieldPtr, value, mask);
}
//////////////////// LoadStructFieldImpl ////////////////////
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual Object LoadObjStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
int mask)
{
UIntPtr *fieldPtr = (UIntPtr *) (structPtr + fieldOffset);
return this.ReadObjImpl(fieldPtr, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual float LoadFloatStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
int mask)
{
float *fieldPtr = (float *) (structPtr + fieldOffset);
return this.ReadImpl(fieldPtr, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual double LoadDoubleStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
int mask)
{
double *fieldPtr = (double *) (structPtr + fieldOffset);
return this.ReadImpl(fieldPtr, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual byte LoadByteStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
int mask)
{
byte *fieldPtr = (byte *) (structPtr + fieldOffset);
return this.ReadImpl(fieldPtr, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual ushort LoadUShortStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
int mask)
{
ushort *fieldPtr = (ushort *) (structPtr + fieldOffset);
return this.ReadImpl(fieldPtr, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual uint LoadUIntStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
int mask)
{
uint *fieldPtr = (uint *) (structPtr + fieldOffset);
return this.ReadImpl(fieldPtr, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual ulong LoadULongStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
int mask)
{
ulong *fieldPtr = (ulong *) (structPtr + fieldOffset);
return this.ReadImpl(fieldPtr, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
UIntPtr LoadUIntPtrStructFieldImpl(UIntPtr structPtr,
UIntPtr fieldOffset,
int mask)
{
UIntPtr *fieldPtr = (UIntPtr *) (structPtr + fieldOffset);
return this.ReadImpl(fieldPtr, mask);
}
//////////////////// StoreVectorElementImpl ////////////////////
[ForceInline]
[NoBarriers]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual void StoreVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
Object value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
this.WriteImpl(vector, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
float value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
this.WriteImpl(vector, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
double value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
this.WriteImpl(vector, offset, value, mask);
}
[Inline]
[NoBarriers]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual void StoreVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
byte value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
this.WriteImpl(vector, offset, value, mask);
}
[Inline]
[AssertDevirtualize]
[NoBarriers]
[NoStackLinkCheckTrans]
protected virtual void StoreVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
ushort value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
this.WriteImpl(vector, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
uint value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
this.WriteImpl(vector, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
ulong value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
this.WriteImpl(vector, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
UIntPtr value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
this.WriteImpl(vector, offset, value, mask);
}
//////////////////// LoadVectorElementImpl ////////////////////
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual Object LoadObjVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadObjImpl(vector, offset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
float LoadFloatVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadFloatImpl(vector, offset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
double LoadDoubleVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadDoubleImpl(vector, offset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
byte LoadByteVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadByteImpl(vector, offset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
ushort LoadUShortVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadUShortImpl(vector, offset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
uint LoadUIntVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadUIntImpl(vector, offset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
ulong LoadULongVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadULongImpl(vector, offset, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
UIntPtr LoadUIntPtrVectorElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadUIntPtrImpl(vector, offset, mask);
}
//////////////////// StoreArrayElementImpl ////////////////////
[ForceInline]
[NoBarriers]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual void StoreArrayElementImpl(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
Object value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(array, index,
arrayElementSize, fieldOffset);
this.WriteImpl(array, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreArrayElementImpl(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
float value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(array, index,
arrayElementSize, fieldOffset);
this.WriteImpl(array, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreArrayElementImpl(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
double value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(array, index,
arrayElementSize, fieldOffset);
this.WriteImpl(array, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreArrayElementImpl(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
byte value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(array, index,
arrayElementSize, fieldOffset);
this.WriteImpl(array, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreArrayElementImpl(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
ushort value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(array, index,
arrayElementSize, fieldOffset);
this.WriteImpl(array, offset, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreArrayElementImpl(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
uint value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(array, index,
arrayElementSize, fieldOffset);
this.WriteImpl(array, offset, value, mask);
}
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual void StoreArrayElementImpl(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
ulong value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(array, index,
arrayElementSize, fieldOffset);
this.WriteImpl(array, offset, value, mask);
}
[Inline]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual void StoreArrayElementImpl(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
UIntPtr value,
int mask)
{
UIntPtr offset = IndexedFieldOffset(array, index,
arrayElementSize, fieldOffset);
this.WriteImpl(array, offset, value, mask);
}
//////////////////// LoadArrayElementImpl ////////////////////
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual Object LoadObjArrayElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadObjImpl(vector, offset, mask);
}
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual
float LoadFloatArrayElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadFloatImpl(vector, offset, mask);
}
[Inline]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
double LoadDoubleArrayElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadDoubleImpl(vector, offset, mask);
}
[Inline]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
byte LoadByteArrayElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadByteImpl(vector, offset, mask);
}
[Inline]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
ushort LoadUShortArrayElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadUShortImpl(vector, offset, mask);
}
[Inline]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
uint LoadUIntArrayElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadUIntImpl(vector, offset, mask);
}
[Inline]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected virtual
ulong LoadULongArrayElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadULongImpl(vector, offset, mask);
}
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual
UIntPtr LoadUIntPtrArrayElementImpl(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
UIntPtr offset = IndexedFieldOffset(vector, index,
arrayElementSize, fieldOffset);
return this.ReadUIntPtrImpl(vector, offset, mask);
}
////////////////// StoreStaticFieldImpl ///////////////////////
[ForceInline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected virtual void StoreStaticFieldImpl(ref Object staticField,
Object value,
int mask)
{
this.WriteImplByRef(ref staticField, value, mask);
}
////////////////// LoadStaticFieldImpl ///////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual Object LoadStaticFieldImpl(ref Object staticField,
int mask)
{
return this.ReadImplByRef(ref staticField, mask);
}
///////////////////////// AtomicSwapImpl ///////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual Object AtomicSwapImpl(ref Object reference,
Object value,
int mask)
{
return Interlocked.Exchange(ref reference,value);
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual int AtomicSwapImpl(ref int reference,
int value,
int mask)
{
return Interlocked.Exchange(ref reference,value);
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual UIntPtr AtomicSwapImpl(ref UIntPtr reference,
UIntPtr value,
int mask)
{
return Interlocked.Exchange(ref reference,value);
}
////////////////////// AtomicCompareAndSwapImpl ////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual Object
AtomicCompareAndSwapImpl(ref Object reference,
Object newValue,
Object comparand,
int mask)
{
return Interlocked.CompareExchange(ref reference,
newValue,comparand);
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual int
AtomicCompareAndSwapImpl(ref int reference,
int newValue,
int comparand,
int mask)
{
return Interlocked.CompareExchange(ref reference,
newValue, comparand);
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual long
AtomicCompareAndSwapImpl(ref long reference,
long newValue,
long comparand,
int mask)
{
return Interlocked.CompareExchange(ref reference,
newValue, comparand);
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual UIntPtr
AtomicCompareAndSwapImpl(ref UIntPtr reference,
UIntPtr newValue,
UIntPtr comparand,
int mask)
{
return Interlocked.CompareExchange(ref reference,
newValue, comparand);
}
/////////////////////////// ForwardImpl ///////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual Object ForwardImpl(Object o,int mask)
{
return o;
}
/////////////////////////// MemoryBarrierImpl ///////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual void MemoryBarrierImpl(int mask)
{
#if !ARM && !ISA_ARM
// HACK: MemoryBarrier is unimplemented in ARM
// and causes compile-time failures when building
// mscorlib in sepcomp mode. This change will break
// CoCo if built with ARM.
Thread.MemoryBarrier();
#endif
}
//////////////////////// PinImpl //////////////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual UIntPtr PinImpl(UIntPtr address,
int mask)
{
return address;
}
/////////////////////// InitObjectImpl ////////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual void InitObjectImpl(Object o,VTable vtable)
{
MyInitObject(o, vtable);
}
[ForceInline]
[NoBarriers]
protected static void BootstrapInitObjectImpl(Object o, VTable vtable)
{
MyInitObject(o, vtable);
}
[ForceInline]
[NoBarriers]
private static void MyInitObject(Object o, VTable vtable)
{
o.vtable = vtable;
}
///////////////////////// Weak Ref ////////////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual Object WeakRefReadImpl(UIntPtr addr, int mask)
{
return Magic.fromAddress(addr);
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual UIntPtr WeakRefWriteImpl(Object obj, int mask)
{
return Magic.addressOf(obj);
}
//////////////////////////// EqImpl ///////////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual bool EqImpl(Object a,Object b, int mask)
{
return a==b;
}
////////////////////////// fast path selection ////////////////
[ForceInline]
[AssertDevirtualize]
protected virtual bool AllowFastPathImpl()
{
return false;
}
///////////////////////// CopyStructImpl ///////////////////////
[AssertDevirtualize]
[Inline]
protected virtual void CopyStructImpl(Object srcObj,
Object dstObj,
VTable vtable,
UIntPtr srcPtr,
UIntPtr dstPtr)
{
CopyStructWithBarrier(vtable, srcPtr, dstPtr);
}
////////////////////////// CloneImpl //////////////////////////
[AssertDevirtualize]
[Inline]
protected virtual void CloneImpl(Object srcObject, Object dstObject)
{
CloneWithBarrier(srcObject, dstObject);
}
/////////////////////// ArrayZeroImpl /////////////////////////
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[AssertDevirtualize]
[Inline]
protected virtual void ArrayZeroImpl(Array array,
int offset,
int length)
{
ArrayZeroWithBarrier(array, offset, length);
}
/////////////////////// ArrayCopyImpl /////////////////////////
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[AssertDevirtualize]
[Inline]
protected virtual void ArrayCopyImpl(Array srcArray, int srcOffset,
Array dstArray, int dstOffset,
int length)
{
ArrayCopyWithBarrier(srcArray, srcOffset,
dstArray, dstOffset,
length);
}
///////////////////// WriteImpl to ptr //////////////////////
[AssertDevirtualize]
[ForceInline]
protected virtual void WriteImpl(UIntPtr *location,
Object value,
int mask)
{
*location = Magic.addressOf(value);
}
[AssertDevirtualize]
[ForceInline]
protected virtual void WriteImpl(float *location,
float value,
int mask)
{
*location = value;
}
[AssertDevirtualize]
[ForceInline]
protected virtual void WriteImpl(double *location,
double value,
int mask)
{
*location = value;
}
[AssertDevirtualize]
[ForceInline]
protected virtual void WriteImpl(byte *location,
byte value,
int mask)
{
*location = value;
}
[AssertDevirtualize]
[ForceInline]
protected virtual void WriteImpl(ushort *location,
ushort value,
int mask)
{
*location = value;
}
[AssertDevirtualize]
[ForceInline]
protected virtual void WriteImpl(uint *location,
uint value,
int mask)
{
*location = value;
}
[AssertDevirtualize]
[ForceInline]
protected virtual void WriteImpl(ulong *location,
ulong value,
int mask)
{
*location = value;
}
[AssertDevirtualize]
[ForceInline]
protected virtual void WriteImpl(UIntPtr *location,
UIntPtr value,
int mask)
{
*location = value;
}
////////////////////// WriteImpl to Object, pointer /////////////////
[AssertDevirtualize]
[ForceInline]
protected virtual void WriteImpl(Object o,
UIntPtr *ptr,
Object value,
int mask)
{
this.WriteImpl(ptr, value, mask);
}
[AssertDevirtualize]
[Inline]
protected virtual void WriteImpl(Object o,
float *ptr,
float value,
int mask)
{
this.WriteImpl(ptr, value, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
double *ptr,
double value,
int mask)
{
this.WriteImpl(ptr, value, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
byte *ptr,
byte value,
int mask)
{
this.WriteImpl(ptr, value, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
ushort *ptr,
ushort value,
int mask)
{
this.WriteImpl(ptr, value, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
uint *ptr,
uint value,
int mask)
{
this.WriteImpl(ptr, value, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
ulong *ptr,
ulong value,
int mask)
{
this.WriteImpl(ptr, value, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
UIntPtr *ptr,
UIntPtr value,
int mask)
{
this.WriteImpl(ptr, value, mask);
}
///////////////////// WriteImpl to Object+offset //////////////////////
[ForceInline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
UIntPtr offset,
Object value,
int mask)
{
this.WriteImpl(o,
(UIntPtr*)(Magic.addressOf(o)+offset),
value,
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
UIntPtr offset,
float value,
int mask)
{
this.WriteImpl(o,
(float*)(Magic.addressOf(o)+offset),
value,
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
UIntPtr offset,
double value,
int mask)
{
this.WriteImpl(o,
(double*)(Magic.addressOf(o)+offset),
value,
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
UIntPtr offset,
byte value,
int mask)
{
this.WriteImpl(o,
(byte*)(Magic.addressOf(o)+offset),
value,
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
UIntPtr offset,
ushort value,
int mask)
{
this.WriteImpl(o,
(ushort*)(Magic.addressOf(o)+offset),
value,
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
UIntPtr offset,
uint value,
int mask)
{
this.WriteImpl(o,
(uint*)(Magic.addressOf(o)+offset),
value,
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
UIntPtr offset,
ulong value,
int mask)
{
this.WriteImpl(o,
(ulong*)(Magic.addressOf(o)+offset),
value,
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual void WriteImpl(Object o,
UIntPtr offset,
UIntPtr value,
int mask)
{
this.WriteImpl(o,
(UIntPtr*)(Magic.addressOf(o)+offset),
value,
mask);
}
///////////////////// WriteImpl to ref //////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual void WriteImplByRef(ref Object location,
Object value,
int mask)
{
location = value;
}
[AssertDevirtualize]
[NoBarriers]
[ForceInline]
protected virtual void WriteImplByRef(ref float location,
float value,
int mask)
{
location = value;
}
[AssertDevirtualize]
[NoBarriers]
[ForceInline]
protected virtual void WriteImplByRef(ref double location,
double value,
int mask)
{
location = value;
}
[AssertDevirtualize]
[NoBarriers]
[ForceInline]
protected virtual void WriteImplByRef(ref byte location,
byte value,
int mask)
{
location = value;
}
[AssertDevirtualize]
[NoBarriers]
[ForceInline]
protected virtual void WriteImplByRef(ref ushort location,
ushort value,
int mask)
{
location = value;
}
[AssertDevirtualize]
[NoBarriers]
[ForceInline]
protected virtual void WriteImplByRef(ref uint location,
uint value,
int mask)
{
location = value;
}
[AssertDevirtualize]
[NoBarriers]
[ForceInline]
protected virtual void WriteImplByRef(ref ulong location,
ulong value,
int mask)
{
location = value;
}
[AssertDevirtualize]
[NoBarriers]
[ForceInline]
protected virtual void WriteImplByRef(ref UIntPtr location,
UIntPtr value,
int mask)
{
location = value;
}
///////////////////// ReadImpl from ptr //////////////////////
[AssertDevirtualize]
[ForceInline]
protected virtual Object ReadObjImpl(UIntPtr *location,
int mask)
{
return Magic.fromAddress(*location);
}
[AssertDevirtualize]
[ForceInline]
protected virtual float ReadImpl(float *location,
int mask)
{
return *location;
}
[AssertDevirtualize]
[ForceInline]
protected virtual double ReadImpl(double *location,
int mask)
{
return *location;
}
[AssertDevirtualize]
[ForceInline]
protected virtual byte ReadImpl(byte *location,
int mask)
{
return *location;
}
[AssertDevirtualize]
[ForceInline]
protected virtual ushort ReadImpl(ushort *location,
int mask)
{
return *location;
}
[AssertDevirtualize]
[ForceInline]
protected virtual uint ReadImpl(uint *location,
int mask)
{
return *location;
}
[AssertDevirtualize]
[ForceInline]
protected virtual ulong ReadImpl(ulong *location,
int mask)
{
return *location;
}
[AssertDevirtualize]
[ForceInline]
protected virtual UIntPtr ReadImpl(UIntPtr *location,
int mask)
{
return *location;
}
///////////////////// ReadImpl from Object, ptr ///////////////////
[Inline]
[AssertDevirtualize]
protected virtual Object ReadObjImpl(Object o,
UIntPtr *ptr,
int mask)
{
return this.ReadObjImpl(ptr, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual float ReadImpl(Object o,
float *ptr,
int mask)
{
return this.ReadImpl(ptr, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual double ReadImpl(Object o,
double *ptr,
int mask)
{
return this.ReadImpl(ptr, mask);
}
[AssertDevirtualize]
[Inline]
protected virtual byte ReadImpl(Object o,
byte *ptr,
int mask)
{
return this.ReadImpl(ptr, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual ushort ReadImpl(Object o,
ushort *ptr,
int mask)
{
return this.ReadImpl(ptr, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual uint ReadImpl(Object o,
uint *ptr,
int mask)
{
return this.ReadImpl(ptr, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual ulong ReadImpl(Object o,
ulong *ptr,
int mask)
{
return this.ReadImpl(ptr, mask);
}
[Inline]
[AssertDevirtualize]
protected virtual UIntPtr ReadImpl(Object o,
UIntPtr *ptr,
int mask)
{
return this.ReadImpl(ptr, mask);
}
///////////////////// ReadImpl from Object+off //////////////////////
[Inline]
[AssertDevirtualize]
protected virtual Object ReadObjImpl(Object o,
UIntPtr offset,
int mask)
{
return this.ReadObjImpl(o,
(UIntPtr*)(Magic.addressOf(o)+offset),
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual float ReadFloatImpl(Object o,
UIntPtr offset,
int mask)
{
return this.ReadImpl(o,
(float*)(Magic.addressOf(o)+offset),
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual double ReadDoubleImpl(Object o,
UIntPtr offset,
int mask)
{
return this.ReadImpl(o,
(double*)(Magic.addressOf(o)+offset),
mask);
}
[AssertDevirtualize]
[Inline]
protected virtual byte ReadByteImpl(Object o,
UIntPtr offset,
int mask)
{
return this.ReadImpl(o,
(byte*)(Magic.addressOf(o)+offset),
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual ushort ReadUShortImpl(Object o,
UIntPtr offset,
int mask)
{
return this.ReadImpl(o,
(ushort*)(Magic.addressOf(o)+offset),
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual uint ReadUIntImpl(Object o,
UIntPtr offset,
int mask)
{
return this.ReadImpl(o,
(uint*)(Magic.addressOf(o)+offset),
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual ulong ReadULongImpl(Object o,
UIntPtr offset,
int mask)
{
return this.ReadImpl(o,
(ulong*)(Magic.addressOf(o)+offset),
mask);
}
[Inline]
[AssertDevirtualize]
protected virtual UIntPtr ReadUIntPtrImpl(Object o,
UIntPtr offset,
int mask)
{
return this.ReadImpl(o,
(UIntPtr*)(Magic.addressOf(o)+offset),
mask);
}
///////////////////// ReadImpl from ref //////////////////////
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual Object ReadImplByRef(ref Object location,
int mask)
{
return location;
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual float ReadImplByRef(ref float location,
int mask)
{
return location;
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual double ReadImplByRef(ref double location,
int mask)
{
return location;
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual byte ReadImplByRef(ref byte location,
int mask)
{
return location;
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual ushort ReadImplByRef(ref ushort location,
int mask)
{
return location;
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual uint ReadImplByRef(ref uint location,
int mask)
{
return location;
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual ulong ReadImplByRef(ref ulong location,
int mask)
{
return location;
}
[AssertDevirtualize]
[ForceInline]
[NoBarriers]
protected virtual UIntPtr ReadImplByRef(ref UIntPtr location,
int mask)
{
return location;
}
/////////////////////// Helpers... //////////////////////////////
[ForceInline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected static UIntPtr IndexedDataPtr(Array array) {
return (UIntPtr) (Magic.addressOf(array) +
(array.vtable.baseLength-(uint)PreHeader.Size));
}
[ForceInline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected static UIntPtr IndexedFieldOffset(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset)
{
return ((UIntPtr)(uint)index * (UIntPtr)(uint)arrayElementSize
+ array.vtable.baseLength
+ fieldOffset
- (UIntPtr)(uint)PreHeader.Size);
}
[ForceInline]
[AssertDevirtualize]
protected static UIntPtr IndexedElementOffset(Array array,
int index)
{
return (UIntPtr)(uint)index * (UIntPtr)(uint)array.vtable.arrayElementSize
+ array.vtable.baseLength
- (UIntPtr)(uint)PreHeader.Size;
}
// copies a span of primitives from one object to another invoking
// word-size read and write barriers along the way.
// mostly useful as part of a greater implementation of struct,
// object, or array copy in a GC that requires primitive barriers.
// note that dstOff, srcOff, and nBytes must be word-aligned.
// call this with great care.
[Inline]
protected static void MemCopyBarrierSlow(Object dst,
UIntPtr dstOff,
Object src,
UIntPtr srcOff,
UIntPtr nBytes) {
for (;nBytes>0;nBytes-=sizeof(UIntPtr)) {
installedBarrier
.WriteImpl(dst,dstOff,
installedBarrier.ReadUIntPtrImpl(src,srcOff,0),0);
dstOff+=sizeof(UIntPtr);
srcOff+=sizeof(UIntPtr);
}
}
// Same as above but without knowledge of the object base.
[Inline]
protected static void MemCopyBarrierSlow(UIntPtr *dstPtr,
UIntPtr *srcPtr,
UIntPtr nBytes) {
for (;nBytes>0;nBytes-=sizeof(UIntPtr)) {
installedBarrier
.WriteImpl(dstPtr,installedBarrier.ReadImpl(srcPtr,0),0);
dstPtr++;
srcPtr++;
}
}
// Really slow way of zeroing memory while invoking write
// barriers. Assumes that everything is word-aligned.
[Inline]
protected static void MemZeroBarrierSlow(Object dst,
UIntPtr dstOff,
UIntPtr nBytes) {
for (;nBytes>0;nBytes-=sizeof(UIntPtr)) {
installedBarrier.WriteImpl(dst,dstOff,UIntPtr.Zero,0);
dstOff+=sizeof(UIntPtr);
}
}
// Really slow way of zeroing memory while invoking write
// barriers. Assumes that everything is word-aligned.
[Inline]
protected static void MemZeroBarrierSlow(UIntPtr *dstPtr,
UIntPtr nBytes) {
for (;nBytes>0;nBytes-=sizeof(UIntPtr)) {
installedBarrier.WriteImpl(dstPtr,UIntPtr.Zero,0);
dstPtr++;
}
}
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected void CopyStructNoBarrier(VTable vtable,
UIntPtr srcPtr,
UIntPtr dstPtr)
{
int preHeaderSize = PreHeader.Size;
int postHeaderSize = PostHeader.Size;
int structSize = ((int) ObjectLayout.ObjectSize(vtable) -
(preHeaderSize + postHeaderSize));
Buffer.MoveMemory((byte *) dstPtr, (byte *) srcPtr, structSize);
}
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected void CopyStructWithBarrier(VTable vtable,
UIntPtr srcPtr,
UIntPtr dstPtr)
{
copyFieldsVisitor.VisitReferenceFields(vtable, srcPtr, dstPtr);
}
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected void CopyStructWithSlowBarrier(Object srcObj,
Object dstObj,
VTable vtable,
UIntPtr srcOff,
UIntPtr dstOff)
{
slowCopyFieldsVisitor.VisitReferenceFields(vtable,
srcObj, dstObj,
srcOff, dstOff);
}
[Inline]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected void CloneNoBarrier(Object srcObject,
Object dstObject)
{
UIntPtr objectSize = System.GCs.ObjectLayout.Sizeof(srcObject);
int preHeaderSize = PreHeader.Size;
int postHeaderSize = PostHeader.Size;
// We don't copy any of the header fields.
Util.MemCopy(Magic.addressOf(dstObject) + postHeaderSize,
Magic.addressOf(srcObject) + postHeaderSize,
objectSize - preHeaderSize - postHeaderSize);
}
[Inline]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected void CloneWithBarrier(Object srcObject,
Object dstObject)
{
copyFieldsVisitor.VisitReferenceFields(srcObject, dstObject);
}
[Inline]
[NoStackLinkCheckTrans]
[AssertDevirtualize]
protected void CloneWithSlowBarrier(Object srcObject,
Object dstObject)
{
slowCopyFieldsVisitor.VisitReferenceFields(srcObject, dstObject);
}
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected void ArrayZeroNoBarrier(Array array, int offset,
int length)
{
UIntPtr dataPtr = IndexedDataPtr(array);
int elementSize = array.vtable.arrayElementSize;
Buffer.ZeroMemory((byte *)dataPtr + offset * elementSize,
length * elementSize);
}
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected void ArrayZeroWithBarrier(Array array, int offset,
int length)
{
UIntPtr dataPtr = IndexedDataPtr(array);
int elementSize = array.vtable.arrayElementSize;
UIntPtr startAddr = dataPtr + offset * elementSize;
zeroFieldsVisitor.VisitReferenceFields(array.vtable,
startAddr, length);
}
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected void ArrayZeroWithSlowBarrier(Array array, int offset,
int length)
{
slowZeroFieldsVisitor
.VisitReferenceFields(array,
IndexedElementOffset(array,offset),
length);
}
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected void ArrayCopyNoBarrier(Array srcArray, int srcOffset,
Array dstArray, int dstOffset,
int length)
{
UIntPtr srcDataAddr = IndexedDataPtr(srcArray);
UIntPtr dstDataAddr = IndexedDataPtr(dstArray);
int elementSize = srcArray.vtable.arrayElementSize;
VTable.Assert(elementSize ==
dstArray.vtable.arrayElementSize);
Buffer.MoveMemory((byte *) (dstDataAddr + dstOffset * elementSize),
(byte *) (srcDataAddr + srcOffset * elementSize),
length * elementSize);
}
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected void ArrayCopyWithBarrier(Array srcArray, int srcOffset,
Array dstArray, int dstOffset,
int length)
{
UIntPtr srcDataAddr = IndexedDataPtr(srcArray);
UIntPtr dstDataAddr = IndexedDataPtr(dstArray);
int elementSize = srcArray.vtable.arrayElementSize;
VTable.Assert(elementSize == dstArray.vtable.arrayElementSize);
UIntPtr srcStartAddr = srcDataAddr + srcOffset * elementSize;
UIntPtr dstStartAddr = dstDataAddr + dstOffset * elementSize;
copyFieldsVisitor.VisitReferenceFields(srcArray.vtable,
srcStartAddr,
dstStartAddr,
length);
}
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[Inline]
[AssertDevirtualize]
[NoStackLinkCheckTrans]
protected void ArrayCopyWithSlowBarrier(Array srcArray, int srcOffset,
Array dstArray, int dstOffset,
int length)
{
VTable.Assert(srcArray.vtable.arrayElementSize
== dstArray.vtable.arrayElementSize);
slowCopyFieldsVisitor
.VisitReferenceFields(srcArray.vtable,
srcArray,
dstArray,
IndexedElementOffset(srcArray,
srcOffset),
IndexedElementOffset(dstArray,
dstOffset),
length);
}
////////////////////// StoreIndirect to pointer ///////////////////
// this isn't called by the compiler
[ForceInline]
[NoStackLinkCheckTrans]
internal static void StoreIndirect(UIntPtr *location,
Object value,
int mask)
{
installedBarrier.StoreIndirectImpl(location, value, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirect(float *location,
float value,
int mask)
{
installedBarrier.StoreIndirectImpl(location, value, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirect(double *location,
double value,
int mask)
{
installedBarrier.StoreIndirectImpl(location, value, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirect(byte *location,
byte value,
int mask)
{
installedBarrier.StoreIndirectImpl(location, value, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirect(ushort *location,
ushort value,
int mask)
{
installedBarrier.StoreIndirectImpl(location, value, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirect(uint *location,
uint value,
int mask)
{
installedBarrier.StoreIndirectImpl(location, value, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirect(ulong *location,
ulong value,
int mask)
{
installedBarrier.StoreIndirectImpl(location, value, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirect(UIntPtr *location,
UIntPtr value,
int mask)
{
installedBarrier.StoreIndirectImpl(location, value, mask);
}
//////////////////// StoreIndirect to ref /////////////////////////
[RequiredByBartok]
[ForceInline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void StoreIndirectByRef(ref Object reference,
Object value,
int mask)
{
installedBarrier.StoreIndirectImplByRef(ref reference,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirectByRef(ref float reference,
float value,
int mask)
{
installedBarrier.StoreIndirectImplByRef(ref reference,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirectByRef(ref double reference,
double value,
int mask)
{
installedBarrier.StoreIndirectImplByRef(ref reference,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirectByRef(ref byte reference,
byte value,
int mask)
{
installedBarrier.StoreIndirectImplByRef(ref reference,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirectByRef(ref ushort reference,
ushort value,
int mask)
{
installedBarrier.StoreIndirectImplByRef(ref reference,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirectByRef(ref uint reference,
uint value,
int mask)
{
installedBarrier.StoreIndirectImplByRef(ref reference,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirectByRef(ref ulong reference,
ulong value,
int mask)
{
installedBarrier.StoreIndirectImplByRef(ref reference,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreIndirectByRef(ref UIntPtr reference,
UIntPtr value,
int mask)
{
installedBarrier.StoreIndirectImplByRef(ref reference,
value, mask);
}
//////////////////// LoadIndirect from ptr /////////////////////////
[Inline]
[NoStackLinkCheckTrans]
internal static Object LoadObjIndirect(UIntPtr *reference,
int mask)
{
return installedBarrier.LoadObjIndirectImpl(reference, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static float LoadIndirect(float* reference,
int mask)
{
return installedBarrier.LoadIndirectImpl(reference, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static double LoadIndirect(double* reference,
int mask)
{
return installedBarrier.LoadIndirectImpl(reference, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static byte LoadIndirect(byte* reference,
int mask)
{
return installedBarrier.LoadIndirectImpl(reference, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static ushort LoadIndirect(ushort* reference,
int mask)
{
return installedBarrier.LoadIndirectImpl(reference, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static uint LoadIndirect(uint* reference,
int mask)
{
return installedBarrier.LoadIndirectImpl(reference, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static ulong LoadIndirect(ulong* reference,
int mask)
{
return installedBarrier.LoadIndirectImpl(reference, mask);
}
[Inline]
[NoStackLinkCheckTrans]
internal static UIntPtr LoadIndirect(UIntPtr* reference,
int mask)
{
return installedBarrier.LoadIndirectImpl(reference, mask);
}
//////////////////// LoadIndirect from ref /////////////////////////
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static Object LoadIndirectByRef(ref Object reference,
int mask)
{
return installedBarrier.LoadIndirectImplByRef(ref reference, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static float LoadIndirectByRef(ref float reference,
int mask)
{
return installedBarrier.LoadIndirectImplByRef(ref reference, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static double LoadIndirectByRef(ref double reference,
int mask)
{
return installedBarrier.LoadIndirectImplByRef(ref reference, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static byte LoadIndirectByRef(ref byte reference,
int mask)
{
return installedBarrier.LoadIndirectImplByRef(ref reference, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ushort LoadIndirectByRef(ref ushort reference,
int mask)
{
return installedBarrier.LoadIndirectImplByRef(ref reference, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static uint LoadIndirectByRef(ref uint reference,
int mask)
{
return installedBarrier.LoadIndirectImplByRef(ref reference, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ulong LoadIndirectByRef(ref ulong reference,
int mask)
{
return installedBarrier.LoadIndirectImplByRef(ref reference, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static UIntPtr LoadIndirectByRef(ref UIntPtr reference,
int mask)
{
return installedBarrier.LoadIndirectImplByRef(ref reference, mask);
}
///////////////////// StoreObjectField /////////////////////////
[RequiredByBartok]
[ForceInline]
[NoStackLinkCheckTrans]
internal static void StoreObjectField(Object obj,
UIntPtr fieldOffset,
Object value,
int mask)
{
installedBarrier.StoreObjectFieldImpl(obj, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreObjectField(Object obj,
UIntPtr fieldOffset,
float value,
int mask)
{
installedBarrier.StoreObjectFieldImpl(obj, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreObjectField(Object obj,
UIntPtr fieldOffset,
double value,
int mask)
{
installedBarrier.StoreObjectFieldImpl(obj, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreObjectField(Object obj,
UIntPtr fieldOffset,
byte value,
int mask)
{
installedBarrier.StoreObjectFieldImpl(obj, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreObjectField(Object obj,
UIntPtr fieldOffset,
ushort value,
int mask)
{
installedBarrier.StoreObjectFieldImpl(obj, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreObjectField(Object obj,
UIntPtr fieldOffset,
uint value,
int mask)
{
installedBarrier.StoreObjectFieldImpl(obj, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreObjectField(Object obj,
UIntPtr fieldOffset,
ulong value,
int mask)
{
installedBarrier.StoreObjectFieldImpl(obj, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreObjectField(Object obj,
UIntPtr fieldOffset,
UIntPtr value,
int mask)
{
installedBarrier.StoreObjectFieldImpl(obj, fieldOffset,
value, mask);
}
///////////////////// LoadObjectField /////////////////////////
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static Object LoadObjObjectField(Object obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadObjObjectFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static float LoadFloatObjectField(Object obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadFloatObjectFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static double LoadDoubleObjectField(Object obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadDoubleObjectFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static byte LoadByteObjectField(Object obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadByteObjectFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ushort LoadUShortObjectField(Object obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadUShortObjectFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static uint LoadUIntObjectField(Object obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadUIntObjectFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ulong LoadULongObjectField(Object obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadULongObjectFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static UIntPtr LoadUIntPtrObjectField(Object obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadUIntPtrObjectFieldImpl(obj,
fieldOffset,
mask);
}
///////////////////// StoreStructField ////////////////////////
// what does this mean for CoCo?
// find base obj pointer. if there is none then
// ignore. if there is then delegate to StoreObjectField
[RequiredByBartok]
[ForceInline]
[NoStackLinkCheckTrans]
internal static void StoreStructField(UIntPtr structPtr,
UIntPtr fieldOffset,
Object value,
int mask)
{
installedBarrier.StoreStructFieldImpl(structPtr, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreStructField(UIntPtr structPtr,
UIntPtr fieldOffset,
float value,
int mask)
{
installedBarrier.StoreStructFieldImpl(structPtr, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreStructField(UIntPtr structPtr,
UIntPtr fieldOffset,
double value,
int mask)
{
installedBarrier.StoreStructFieldImpl(structPtr, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreStructField(UIntPtr structPtr,
UIntPtr fieldOffset,
byte value,
int mask)
{
installedBarrier.StoreStructFieldImpl(structPtr, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreStructField(UIntPtr structPtr,
UIntPtr fieldOffset,
ushort value,
int mask)
{
installedBarrier.StoreStructFieldImpl(structPtr, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreStructField(UIntPtr structPtr,
UIntPtr fieldOffset,
uint value,
int mask)
{
installedBarrier.StoreStructFieldImpl(structPtr, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreStructField(UIntPtr structPtr,
UIntPtr fieldOffset,
ulong value,
int mask)
{
installedBarrier.StoreStructFieldImpl(structPtr, fieldOffset,
value, mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreStructField(UIntPtr structPtr,
UIntPtr fieldOffset,
UIntPtr value,
int mask)
{
installedBarrier.StoreStructFieldImpl(structPtr, fieldOffset,
value, mask);
}
///////////////////// LoadStructField ////////////////////////
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static Object LoadObjStructField(UIntPtr obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadObjStructFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static float LoadFloatStructField(UIntPtr obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadFloatStructFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static double LoadDoubleStructField(UIntPtr obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadDoubleStructFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static byte LoadByteStructField(UIntPtr obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadByteStructFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ushort LoadUShortStructField(UIntPtr obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadUShortStructFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static uint LoadUIntStructField(UIntPtr obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadUIntStructFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ulong LoadULongStructField(UIntPtr obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadULongStructFieldImpl(obj,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static UIntPtr LoadUIntPtrStructField(UIntPtr obj,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadUIntPtrStructFieldImpl(obj,
fieldOffset,
mask);
}
////////////////////// StoreVectorElement ////////////////////
[RequiredByBartok]
[ForceInline]
[NoStackLinkCheckTrans]
internal static void StoreVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
Object value,
int mask)
{
installedBarrier.StoreVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
float value,
int mask)
{
installedBarrier.StoreVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
double value,
int mask)
{
installedBarrier.StoreVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
byte value,
int mask)
{
installedBarrier.StoreVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
ushort value,
int mask)
{
installedBarrier.StoreVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
uint value,
int mask)
{
installedBarrier.StoreVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
ulong value,
int mask)
{
installedBarrier.StoreVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
UIntPtr value,
int mask)
{
installedBarrier.StoreVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
////////////////////// LoadVectorElement ////////////////////
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static Object LoadObjVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadObjVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static float LoadFloatVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier
.LoadFloatVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static double LoadDoubleVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier
.LoadDoubleVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static byte LoadByteVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadByteVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ushort LoadUShortVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier
.LoadUShortVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static uint LoadUIntVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadUIntVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ulong LoadULongVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier
.LoadULongVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static UIntPtr LoadUIntPtrVectorElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier
.LoadUIntPtrVectorElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
///////////////////// StoreArrayElement /////////////////////
[RequiredByBartok]
[ForceInline]
[NoStackLinkCheckTrans]
internal static void StoreArrayElement(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
Object value,
int mask)
{
installedBarrier.StoreArrayElementImpl(array,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreArrayElement(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
float value,
int mask)
{
installedBarrier.StoreArrayElementImpl(array,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreArrayElement(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
double value,
int mask)
{
installedBarrier.StoreArrayElementImpl(array,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreArrayElement(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
byte value,
int mask)
{
installedBarrier.StoreArrayElementImpl(array,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreArrayElement(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
ushort value,
int mask)
{
installedBarrier.StoreArrayElementImpl(array,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreArrayElement(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
uint value,
int mask)
{
installedBarrier.StoreArrayElementImpl(array,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreArrayElement(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
ulong value,
int mask)
{
installedBarrier.StoreArrayElementImpl(array,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static void StoreArrayElement(Array array,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
UIntPtr value,
int mask)
{
installedBarrier.StoreArrayElementImpl(array,
index,
arrayElementSize,
fieldOffset,
value,
mask);
}
////////////////////// LoadArrayElement ////////////////////
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static Object LoadObjArrayElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadObjArrayElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static float LoadFloatArrayElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadFloatArrayElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static double LoadDoubleArrayElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier
.LoadDoubleArrayElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static byte LoadByteArrayElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadByteArrayElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ushort LoadUShortArrayElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier
.LoadUShortArrayElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static uint LoadUIntArrayElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadUIntArrayElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static ulong LoadULongArrayElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier.LoadULongArrayElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
[RequiredByBartok]
[Inline]
[NoStackLinkCheckTrans]
internal static UIntPtr LoadUIntPtrArrayElement(Array vector,
int index,
int arrayElementSize,
UIntPtr fieldOffset,
int mask)
{
return installedBarrier
.LoadUIntPtrArrayElementImpl(vector,
index,
arrayElementSize,
fieldOffset,
mask);
}
//////////////////// StoreStaticField /////////////////////////
// only support ref wb for now, since nobody needs integral
// wb on statics
[RequiredByBartok]
[ForceInline]
[NoStackLinkCheckTrans]
internal static void StoreStaticField(ref Object staticField,
Object value,
int mask)
{
installedBarrier.StoreStaticFieldImpl(ref staticField,
value, mask);
}
//////////////////// LoadStaticField /////////////////////////
// only support ref rb for now, since nobody needs integral
// rb on statics
[RequiredByBartok]
[Inline]
internal static Object LoadStaticField(ref Object staticField,
int mask)
{
return installedBarrier.LoadStaticFieldImpl(ref staticField,
mask);
}
///////////////////////// Increment/Decrement /////////////////////
// REVIEW: maybe optimize these. or not.
[ForceInline]
[RequiredByBartok]
internal static int AtomicIncrement(ref int reference,
int maskmask)
{
for (;;) {
int oldVal = reference;
if (Interlocked.CompareExchange(ref reference,
oldVal+1,
oldVal)
== oldVal) {
return oldVal+1;
}
}
}
[ForceInline]
[RequiredByBartok]
internal static int AtomicDecrement(ref int reference,
int mask)
{
for (;;) {
int oldVal = reference;
if (Interlocked.CompareExchange(ref reference,
oldVal-1,
oldVal)
== oldVal) {
return oldVal-1;
}
}
}
/////////////////////////// AtomicSwap /////////////
[RequiredByBartok]
[ForceInline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static Object AtomicSwap(ref Object reference,
Object value,
int mask)
{
return installedBarrier.AtomicSwapImpl(ref reference,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static int AtomicSwap(ref int reference,
int value,
int mask)
{
return installedBarrier.AtomicSwapImpl(ref reference,
value,
mask);
}
[RequiredByBartok]
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static UIntPtr AtomicSwap(ref UIntPtr reference,
UIntPtr value,
int mask)
{
return installedBarrier.AtomicSwapImpl(ref reference,
value,
mask);
}
//////////////// AtomicCompareAndSwap /////////////////
[RequiredByBartok]
[ForceInline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static Object AtomicCompareAndSwap(ref Object reference,
Object newValue,
Object comparand,
int mask)
{
return
installedBarrier.AtomicCompareAndSwapImpl(ref reference,
newValue,
comparand,
mask);
}
[RequiredByBartok]
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static int AtomicCompareAndSwap(ref int reference,
int newValue,
int comparand,
int mask)
{
return
installedBarrier.AtomicCompareAndSwapImpl(ref reference,
newValue,
comparand,
mask);
}
[RequiredByBartok]
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static long AtomicCompareAndSwap(ref long reference,
long newValue,
long comparand,
int mask)
{
return
installedBarrier.AtomicCompareAndSwapImpl(ref reference,
newValue,
comparand,
mask);
}
[RequiredByBartok]
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static UIntPtr AtomicCompareAndSwap(ref UIntPtr reference,
UIntPtr newValue,
UIntPtr comparand,
int mask)
{
return
installedBarrier.AtomicCompareAndSwapImpl(ref reference,
newValue,
comparand,
mask);
}
/////////////////////// Forward ////////////////////////
[RequiredByBartok]
[ForceInline]
internal static Object Forward(Object o,int mask)
{
return installedBarrier.ForwardImpl(o,mask);
}
/////////////////////// MemmoryBarrier ///////////////////////////
[RequiredByBartok]
[ForceInline]
internal static void MemoryBarrier(int mask)
{
installedBarrier.MemoryBarrierImpl(mask);
}
//////////////////////// Pin ///////////////////////////
//
// takes an address at which you wish to pin and returns to
// you a suitable "pinned" address to use. may also cause
// you to wait for any arbitrary amount of time. but the
// invariants are:
// -> the address returned is pinned until the next safepoint,
// or until no pinned locals refer to it, whichever comes
// later.
// -> even though the address returned may be different from
// the address given, and even though non-pinned pointers
// to the object may use totally different addresses, you're
// guaranteed that the address returned is the "true"
// address of the object, and any modifications made to it
// will be seen by anyone else accessing the same object, even
// if they do it via a different address.
[RequiredByBartok]
[ForceInline]
internal static UIntPtr Pin(UIntPtr address,
int mask)
{
return installedBarrier.PinImpl(address, mask);
}
////////////////////////// Initialize Object /////////////////
[Inline]
internal static void InitObject(Object o,VTable vtable)
{
installedBarrier.InitObjectImpl(o,vtable);
}
// TODO: Eliminate this hack when possible. That should be either
// when the compiler is smart enough to devirtualize the
// installedBarrier.InitObjectImpl call in Barrier.InitObject when
// doing sepcomp, or when we stop using a class hierarchy of barriers.
//
// This method is called only from BootstrapMemory and is required
// when the compiler cannot statically resolve which barrier to
// use and the installedBarrier field has not been initialized.
internal static void BootstrapInitObject(Object o, VTable vtable)
{
switch (GC.wbType) {
#if !SINGULARITY || MARK_SWEEP_COLLECTOR || NULL_COLLECTOR
case WBType.noWB: {
EmptyWriteBarrier.BootstrapInitObjectImpl(o, vtable);
break;
}
#endif
#if !SINGULARITY || SEMISPACE_COLLECTOR || SLIDING_COLLECTOR || ADAPTIVE_COPYING_COLLECTOR
case WBType.Generational: {
GenerationalWriteBarrier.BootstrapInitObjectImpl(o, vtable);
break;
}
#endif
#if !SINGULARITY || CONCURRENT_MS_COLLECTOR
case WBType.CMS: {
WriteBarrierCMS.BootstrapInitObjectImpl(o, vtable);
break;
}
#endif
#if !SINGULARITY || ATOMIC_RC_COLLECTOR
case WBType.ARC: {
AtomicRCWriteBarrier.BootstrapInitObjectImpl(o, vtable);
break;
}
#endif
#if !SINGULARITY || SEMISPACE_COLLECTOR || SLIDING_COLLECTOR || ADAPTIVE_COPYING_COLLECTOR
case WBType.AllCards: {
AllCardsWriteBarrier.BootstrapInitObjectImpl(o, vtable);
break;
}
#endif
#if !SINGULARITY
case WBType.ExpandingCoCo: {
ExpandingCoCoBarrier.BootstrapInitObjectImpl(o, vtable);
break;
}
case WBType.ProbabilisticCoCo: {
ProbabilisticCoCoBarrier.BootstrapInitObjectImpl(o, vtable);
break;
}
case WBType.AbortingCoCo: {
AbortingCoCoBarrier.BootstrapInitObjectImpl(o, vtable);
break;
}
case WBType.BrooksTest: {
BrooksBarrierTest.BootstrapInitObjectImpl(o, vtable);
break;
}
case WBType.BrooksCMSTest: {
BrooksCMSBarrierTest.BootstrapInitObjectImpl(o, vtable);
break;
}
#endif
default: {
VTable.NotReached("Unknown write barrier type: "+GC.wbType);
break;
}
}
}
//////////////////////// Weak Ref ////////////////////////////
[Inline]
internal static Object WeakRefRead(UIntPtr addr,
int mask)
{
return installedBarrier.WeakRefReadImpl(addr, mask);
}
[Inline]
internal static UIntPtr WeakRefWrite(Object obj,
int mask)
{
return installedBarrier.WeakRefWriteImpl(obj, mask);
}
///////////////////////// Equality Barriers ///////////////////
[RequiredByBartok]
[Inline]
internal static bool Eq(Object a, Object b, int mask)
{
return installedBarrier.EqImpl(a, b, mask);
}
[RequiredByBartok]
[Inline]
internal static bool Neq(Object a, Object b, int mask)
{
return !Eq(a, b, mask);
}
////////////////////////// fast path selection ////////////////
[RequiredByBartok]
[ForceInline]
internal static bool AllowFastPath()
{
return installedBarrier.AllowFastPathImpl();
}
/////////////////////// CopyStruct ////////////////////////////
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void CopyStruct(Object srcObj,
Object dstObj,
VTable vtable,
UIntPtr srcPtr,
UIntPtr dstPtr)
{
installedBarrier.CopyStructImpl(srcObj, dstObj,
vtable, srcPtr, dstPtr);
}
//////////////////////////// Clone /////////////////////////////
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void Clone(Object srcObject, Object dstObject)
{
installedBarrier.CloneImpl(srcObject, dstObject);
}
//////////////////////// ArrayZero //////////////////////////////
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void ArrayZero(Array array, int offset, int length)
{
installedBarrier.ArrayZeroImpl(array, offset, length);
}
////////////////////////// ArrayCopy ////////////////////////////
// 'offset' is not relative to the lower bound, but is a count
// of elements from the first element in the array.
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void ArrayCopy(Array srcArray, int srcOffset,
Array dstArray, int dstOffset,
int length)
{
installedBarrier.ArrayCopyImpl(srcArray, srcOffset,
dstArray, dstOffset,
length);
}
////////////////////// Write ////////////////////////////
[ForceInline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void Write(UIntPtr *location, Object value, int mask)
{
installedBarrier.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void Write(float *location, float value, int mask)
{
installedBarrier.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void Write(double *location, double value, int mask)
{
installedBarrier.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void Write(byte *location, byte value, int mask)
{
installedBarrier.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void Write(ushort *location, ushort value, int mask)
{
installedBarrier.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void Write(uint *location, uint value, int mask)
{
installedBarrier.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void Write(ulong *location, ulong value, int mask)
{
installedBarrier.WriteImpl(location, value, mask);
}
[Inline]
[NoBarriers]
[NoStackLinkCheckTrans]
internal static void Write(UIntPtr *location, UIntPtr value, int mask)
{
installedBarrier.WriteImpl(location, value, mask);
}
///////////////////////// Visitors... /////////////////////////////
private class CopyFieldsVisitor : OffsetReferenceVisitor
{
// Struct copy
internal void VisitReferenceFields(VTable vtable,
UIntPtr srcPtr,
UIntPtr dstPtr)
{
int postHeaderSize = PostHeader.Size;
ObjectDescriptor objDesc =
new ObjectDescriptor(vtable,
srcPtr - postHeaderSize,
dstPtr - postHeaderSize,
(UIntPtr) postHeaderSize);
VisitReferenceFieldsTemplate(ref objDesc);
int preHeaderSize = PreHeader.Size;
UIntPtr limitSize =
ObjectLayout.ObjectSize(vtable) - preHeaderSize;
UIntPtr previouslyDone = objDesc.extra;
UIntPtr tailSize = limitSize - previouslyDone;
if (tailSize > UIntPtr.Zero) {
Util.MemCopy(objDesc.secondBase + previouslyDone,
objDesc.objectBase + previouslyDone,
tailSize);
}
}
internal void VisitReferenceFields(Object srcObject,
Object dstObject)
{
int postHeaderSize = PostHeader.Size;
ObjectDescriptor objDesc =
new ObjectDescriptor(srcObject.vtable,
Magic.addressOf(srcObject),
Magic.addressOf(dstObject),
(UIntPtr) postHeaderSize);
UIntPtr objectSize = VisitReferenceFieldsTemplate(ref objDesc);
int preHeaderSize = PreHeader.Size;
UIntPtr limitSize = objectSize - preHeaderSize;
UIntPtr previouslyDone = objDesc.extra;
UIntPtr tailSize = limitSize - previouslyDone;
if (tailSize > UIntPtr.Zero) {
Util.MemCopy(objDesc.secondBase + previouslyDone,
objDesc.objectBase + previouslyDone,
tailSize);
}
}
// Partial array copy
internal void VisitReferenceFields(VTable vtable,
UIntPtr srcElementPtr,
UIntPtr dstElementPtr,
int length)
{
ObjectDescriptor objDesc =
new ObjectDescriptor(vtable, srcElementPtr, dstElementPtr);
VisitReferenceFieldsTemplate(ref objDesc, length);
UIntPtr dataSize =
srcElementPtr + length * vtable.arrayElementSize;
UIntPtr srcLimitAddr = Util.UIntPtrPad(dataSize);
UIntPtr previouslyDone = objDesc.objectBase + objDesc.extra;
UIntPtr tailSize = srcLimitAddr - previouslyDone;
if (tailSize > UIntPtr.Zero) {
Util.MemCopy(objDesc.secondBase + objDesc.extra,
previouslyDone, tailSize);
}
}
internal override void FieldOffset(UIntPtr offset,
ref ObjectDescriptor objDesc)
{
UIntPtr previouslyDone = objDesc.extra;
objDesc.extra = offset + UIntPtr.Size;
UIntPtr norefSize = offset - previouslyDone;
if (norefSize > UIntPtr.Zero) {
Util.MemCopy(objDesc.secondBase + previouslyDone,
objDesc.objectBase + previouslyDone,
norefSize);
}
UIntPtr *srcAddr = (UIntPtr *) (objDesc.objectBase + offset);
UIntPtr *dstAddr = (UIntPtr *) (objDesc.secondBase + offset);
Object fieldValue = installedBarrier.ReadObjImpl(srcAddr, 0);
fieldValue =
installedBarrier.ForwardImpl(fieldValue,
BarrierMask.Forward.Nullable);
installedBarrier.WriteImpl(dstAddr, fieldValue, 0);
}
}
private class SlowCopyFieldsVisitor : OffsetReferenceVisitor
{
// Struct copy
internal void VisitReferenceFields(VTable vtable,
Object src,
Object dst,
UIntPtr srcOff,
UIntPtr dstOff)
{
int postHeaderSize = PostHeader.Size;
ObjectDescriptor objDesc =
new ObjectDescriptor(vtable,
Magic.addressOf(src)
+ srcOff - postHeaderSize,
Magic.addressOf(dst)
+ dstOff - postHeaderSize,
(UIntPtr) postHeaderSize,
src,dst);
VisitReferenceFieldsTemplate(ref objDesc);
int preHeaderSize = PreHeader.Size;
UIntPtr limitSize =
ObjectLayout.ObjectSize(vtable) - preHeaderSize;
UIntPtr previouslyDone = objDesc.extra;
UIntPtr tailSize = limitSize - previouslyDone;
MemCopyBarrierSlow(dst,
objDesc.secondBase
+ previouslyDone
- Magic.addressOf(dst),
src,
objDesc.objectBase
+ previouslyDone
- Magic.addressOf(src),
tailSize);
}
// Partial array copy
internal void VisitReferenceFields(VTable vtable,
Object srcArr,
Object dstArr,
UIntPtr srcOff,
UIntPtr dstOff,
int length)
{
ObjectDescriptor objDesc =
new ObjectDescriptor(vtable,
Magic.addressOf(srcArr) + srcOff,
Magic.addressOf(dstArr) + dstOff,
UIntPtr.Zero,
srcArr, dstArr);
VisitReferenceFieldsTemplate(ref objDesc, length);
UIntPtr srcLimitAddr =
Magic.addressOf(srcArr) + srcOff
+ length * vtable.arrayElementSize;
UIntPtr previouslyDone = objDesc.objectBase + objDesc.extra;
UIntPtr tailSize = srcLimitAddr - previouslyDone;
MemCopyBarrierSlow(dstArr,
objDesc.secondBase + objDesc.extra
- Magic.addressOf(dstArr),
srcArr,
previouslyDone - Magic.addressOf(srcArr),
tailSize);
}
internal void VisitReferenceFields(Object srcObject,
Object dstObject)
{
int postHeaderSize = PostHeader.Size;
ObjectDescriptor objDesc =
new ObjectDescriptor(srcObject.vtable,
Magic.addressOf(srcObject),
Magic.addressOf(dstObject),
(UIntPtr) postHeaderSize,
srcObject,
dstObject);
UIntPtr objectSize = VisitReferenceFieldsTemplate(ref objDesc);
int preHeaderSize = PreHeader.Size;
UIntPtr limitSize = objectSize - preHeaderSize;
UIntPtr previouslyDone = objDesc.extra;
UIntPtr tailSize = limitSize - previouslyDone;
MemCopyBarrierSlow(dstObject,previouslyDone,
srcObject,previouslyDone,
tailSize);
}
internal override void FieldOffset(UIntPtr offset,
ref ObjectDescriptor objDesc)
{
UIntPtr previouslyDone = objDesc.extra;
objDesc.extra = offset + UIntPtr.Size;
UIntPtr norefSize = offset - previouslyDone;
MemCopyBarrierSlow(objDesc.realSecondBase,
previouslyDone + objDesc.secondBase
- Magic.addressOf(objDesc.realSecondBase),
objDesc.realObjectBase,
previouslyDone + objDesc.objectBase
- Magic.addressOf(objDesc.realObjectBase),
norefSize);
Object fieldValue =
installedBarrier
.ReadObjImpl(objDesc.realObjectBase,
offset + objDesc.objectBase
- Magic.addressOf(objDesc.realObjectBase),
0);
installedBarrier
.WriteImpl(objDesc.realSecondBase,
offset + objDesc.secondBase
- Magic.addressOf(objDesc.realSecondBase),
fieldValue,
0);
}
}
private class ZeroFieldsVisitor : OffsetReferenceVisitor
{
internal void VisitReferenceFields(VTable vtable,
UIntPtr elementAddr,
int length)
{
ObjectDescriptor objDesc =
new ObjectDescriptor(vtable, elementAddr);
VisitReferenceFieldsTemplate(ref objDesc, length);
UIntPtr limitAddr =
elementAddr + length * vtable.arrayElementSize;
UIntPtr previouslyDone = objDesc.objectBase + objDesc.extra;
UIntPtr tailSize = limitAddr - previouslyDone;
if (tailSize > UIntPtr.Zero) {
Buffer.ZeroMemory((byte *) previouslyDone, tailSize);
}
}
internal override void FieldOffset(UIntPtr offset,
ref ObjectDescriptor objDesc)
{
UIntPtr previouslyDone = objDesc.extra;
objDesc.extra = offset + UIntPtr.Size;
UIntPtr norefSize = offset - previouslyDone;
if (norefSize > UIntPtr.Zero) {
Util.MemClear(objDesc.objectBase + previouslyDone,
norefSize);
}
UIntPtr *fieldAddr = (UIntPtr *) (objDesc.objectBase + offset);
installedBarrier.WriteImpl(fieldAddr, null, 0);
}
}
private class SlowZeroFieldsVisitor : OffsetReferenceVisitor
{
internal void VisitReferenceFields(Object arr,
UIntPtr off,
int length)
{
ObjectDescriptor objDesc =
new ObjectDescriptor(arr.vtable,
Magic.addressOf(arr) + off,
off,
UIntPtr.Zero,
arr,
null);
VisitReferenceFieldsTemplate(ref objDesc, length);
UIntPtr limitAddr =
Magic.addressOf(arr) + off + length * arr.vtable.arrayElementSize;
UIntPtr previouslyDone = objDesc.objectBase + objDesc.extra;
UIntPtr tailSize = limitAddr - previouslyDone;
Barrier.MemZeroBarrierSlow(arr,
previouslyDone - Magic.addressOf(arr),
tailSize);
}
internal override void FieldOffset(UIntPtr offset,
ref ObjectDescriptor objDesc)
{
UIntPtr previouslyDone = objDesc.extra;
objDesc.extra = offset + UIntPtr.Size;
UIntPtr norefSize = offset - previouslyDone;
Barrier
.MemZeroBarrierSlow(objDesc.realObjectBase,
objDesc.secondBase + previouslyDone,
norefSize);
installedBarrier
.WriteImpl(objDesc.realObjectBase,
objDesc.secondBase + offset,
null,
0);
}
}
}
}