internal override void FieldOffset(UIntPtr offset,
ref ObjectDescriptor objDesc)
{
UIntPtr *dstAddr = (UIntPtr *)(objDesc.objectBase + offset);
((LowAbortCoCoBarrier)Barrier.installedBarrier).TargetBarrierImpl(*dstAddr);
}
internal override unsafe void Visit(UIntPtr *loc)
{
UIntPtr objAddr = *loc;
Object obj = Magic.fromAddress(objAddr);
uint refState = obj.REF_STATE;
if ((refState & countingONFlagMask) == 0 ||
(refState & markFlagMask) == 0)
{
return;
}
obj.REF_STATE = refState & ~markFlagMask;
uint refCount = refState & refCountMask;
if (refCount > 0)
{
// This object isn't leaked data, so
// clear the PLC link in its header.
setPLCLink(obj, null);
internalIncrementer.Traverse(objAddr);
}
else
{
this.workList.Write(objAddr);
}
}
void ScanStaticData(DirectReferenceVisitor referenceVisitor)
{
Finalizer.VisitBootstrapData(referenceVisitor);
for (int section = 0; section < sectionCount; section++)
{
int size = (int)
(*(dataSectionEnd + section) - *(dataSectionBase + section));
int iters = (size + 31) / 32;
UIntPtr *ptr = *(dataSectionBase + section);
uint * pointerBitmap = *(staticDataPointerBitMap + section);
for (int i = 0; i < iters; i++)
{
uint mask = *pointerBitmap++;
if (mask != 0)
{
for (int j = 0; j < 32; j++)
{
if ((mask & 1) != 0 && *ptr != UIntPtr.Zero)
{
referenceVisitor.Visit(ptr);
}
ptr++;
mask >>= 1;
}
}
else
{
ptr += 32;
}
}
}
}
internal override unsafe void Visit(UIntPtr *loc)
{
UIntPtr pageLoc = PageTable.Page((UIntPtr)loc);
PageType pageType = PageTable.Type(pageLoc);
if (pageType != PageType.NonGC &&
pageType != PageType.Stack)
{
VTable.Assert(PageTable.IsGcPage(pageLoc),
@"PageTable.IsGcPage(pageLoc)");
return;
}
uint addr = (uint)*loc;
if (pageType == PageType.NonGC || (addr & 0x03) == 0)
{
this.visitor.Visit(loc);
}
if (pageType == PageType.Stack)
{
*loc = (UIntPtr)(addr | 0x01);
}
}
public unsafe CefResponseFilterStatus Filter(void* data_in, UIntPtr data_in_size, UIntPtr* data_in_read, void* data_out, UIntPtr data_out_size, UIntPtr* data_out_written)
{
fixed (cef_response_filter_t* self = &this)
{
return ((delegate* unmanaged[Stdcall]<cef_response_filter_t*, void*, UIntPtr, UIntPtr*, void*, UIntPtr, UIntPtr*, CefResponseFilterStatus>)filter)(self, data_in, data_in_size, data_in_read, data_out, data_out_size, data_out_written);
}
}
void Filter(UIntPtr *location, ref ObjectDescriptor objDesc)
{
if (*location != UIntPtr.Zero)
{
this.Visit(location);
}
}
internal unsafe override void Visit(UIntPtr *loc)
{
UIntPtr addr = *loc;
// Ignore pointers out of our memory area
if (PageTable.IsForeignAddr(addr))
{
return;
}
UIntPtr page = PageTable.Page(addr);
if (!PageTable.IsMyGcPage(page))
{
PageType pageType = PageTable.Type(page);
#if SINGULARITY_PROCESS
// We have to allow reference pointers to the
// ThreadContext, which lives in the kernel space.
VTable.Assert((PageTable.IsNonGcPage(pageType) &&
PageTable.IsMyPage(page)) ||
PageTable.IsStackPage(pageType) ||
PageTable.IsSharedPage(pageType) ||
(PageTable.IsGcPage(pageType) &&
PageTable.IsKernelPage(page)));
#else
VTable.Assert((PageTable.IsNonGcPage(pageType) &&
PageTable.IsMyPage(page)) ||
PageTable.IsStackPage(pageType) ||
PageTable.IsSharedPage(pageType));
#endif
return;
}
UIntPtr objectAddr = SegregatedFreeList.Find(addr);
markAndProcessReferenceVisitor.Visit(&objectAddr);
}
internal unsafe override void Visit(UIntPtr *loc)
{
UIntPtr addr = *loc;
UIntPtr page = PageTable.Page(addr);
PageType pageType = PageTable.Type(page);
if (!PageTable.IsZombiePage(pageType))
{
VTable.Assert(PageTable.IsGcPage(pageType) ||
PageTable.IsNonGcPage(pageType) ||
PageTable.IsStackPage(pageType) ||
PageTable.IsSharedPage(pageType));
return;
}
UIntPtr vtableAddr = Allocator.GetObjectVTable(addr);
// Mark object
if (vtableAddr == UIntPtr.Zero)
{
VTable.DebugPrint("Found null vtable in MarkReference (loc = 0x{0:x8}, addr = 0x{1:x8})\n",
__arglist(((UIntPtr)loc), addr));
VTable.NotReached();
}
*loc = vtableAddr;
Allocator.SetObjectVTable(addr, (UIntPtr)loc + 1);
// If first visit to the object, schedule visit of fields
if ((vtableAddr & 0x1) == 0)
{
MarkVisit(addr, vtableAddr & (UIntPtr) ~2U);
}
}
public static unsafe bool GetSharedSourceHandlesImpl(uint infoId,
UIntPtr *storageHandle,
UIntPtr *sourceHandle,
UIntPtr *eventTypeHandle)
{
return(GetSharedSourceHandles(infoId, out *storageHandle, out *sourceHandle, out *eventTypeHandle));
}
public unsafe void GetPEMEncodedIssuerChain(UIntPtr *chainCount, cef_binary_value_t **chain)
{
fixed(cef_x509certificate_t *self = &this)
{
((delegate * unmanaged[Stdcall] < cef_x509certificate_t *, UIntPtr *, cef_binary_value_t **, void >)get_pemencoded_issuer_chain)(self, chainCount, chain);
}
}
internal unsafe override void Visit(UIntPtr *loc)
{
UIntPtr addr = *loc;
UIntPtr page = PageTable.Page(addr);
PageType pageType = PageTable.Type(page);
if (!PageTable.IsZombiePage(pageType))
{
VTable.Assert(PageTable.IsGcPage(pageType) ||
PageTable.IsNonGcPage(pageType) ||
PageTable.IsStackPage(pageType) ||
PageTable.IsSharedPage(pageType));
return;
}
UIntPtr vtableAddr = Allocator.GetObjectVTable(addr);
if ((vtableAddr & 0x1) == 0x1)
{
// Link this field to be updated
*loc = vtableAddr;
Allocator.SetObjectVTable(addr, (UIntPtr)loc + 1);
}
else
{
// Zero the reference (not marked)
*loc = UIntPtr.Zero;
}
}
protected override void WriteImpl(UIntPtr *location,
Object value,
int mask)
{
CMSMarking.ReferenceCheck(location, value, mask);
*location = Magic.addressOf(value);
}
public unsafe bool ReadActiveSourceItem(UIntPtr sourceHandle,
int item,
UIntPtr *type,
byte *buffer,
UInt16 bufferSize)
{
Lock.AcquireMutex();
object source = SourcesHandleTable[sourceHandle];
if (source != null)
{
ActiveSource activeSource = source as ActiveSource;
if (activeSource != null)
{
bool success = activeSource.GetActiveEntry(item, type, buffer, bufferSize);
Lock.ReleaseMutex();
return(success);
}
}
Lock.ReleaseMutex();
return(false);
}
internal static void VerifyUnusedPage(UIntPtr page, bool containsHeader)
{
if (PageTable.Type(page) == PageType.UnusedDirty)
{
return;
}
// Verify that the page is indeed clean
UIntPtr *startAddr = (UIntPtr *)PageTable.PageAddr(page);
UIntPtr *endAddr = (UIntPtr *)PageTable.PageAddr(page + 1);
// If the page contains a header then we can't expect the header
// to be clean.
if (containsHeader)
{
startAddr += (uint)
(Util.UIntPtrPad((UIntPtr)sizeof(UnusedBlockHeader))
/ (uint)sizeof(UIntPtr));
}
while (startAddr < endAddr)
{
VTable.Assert(*startAddr == UIntPtr.Zero,
"UnusedClean page contains nonzero data");
startAddr++;
}
}
public unsafe void EqualityTest1()
{
UIntPtr *sample = stackalloc UIntPtr[4];
int checksum = 0;
int address1 = (int)sample;
Console.WriteLine("Original Address: {0:X}", address1);
checksum += address1;
IntPtr address2 = new IntPtr(sample);
Console.WriteLine("IntPtr Address: {0:X}", address2.ToInt32());
checksum += address2.ToInt32();
UIntPtrPointer address3 = new UIntPtrPointer(address2);
Console.WriteLine("UIntPtrPointer Address (from IntPtr): {0:X}", address3.ToInt32());
checksum += address3.ToInt32();
UIntPtrPointer address4 = new UIntPtrPointer(address1);
Console.WriteLine("UIntPtrPointer Address (from Int32): {0:X}", address4.ToInt32());
checksum += address4.ToInt32();
int checksumDigest = checksum / 4;
Assert.AreEqual(checksumDigest, address1);
Assert.AreEqual(checksumDigest, address2.ToInt32());
Assert.AreEqual(checksumDigest, address3.ToInt32());
Assert.AreEqual(checksumDigest, address4.ToInt32());
}
public unsafe void GetElements(UIntPtr *elementsCount, cef_post_data_element_t **elements)
{
fixed(cef_post_data_t *self = &this)
{
((delegate * unmanaged[Stdcall] < cef_post_data_t *, UIntPtr *, cef_post_data_element_t **, void >)get_elements)(self, elementsCount, elements);
}
}
internal unsafe override void Visit(UIntPtr *loc)
{
UIntPtr addr = *loc;
// Ignore pointers out of our memory area
if (PageTable.IsForeignAddr(addr))
{
return;
}
UIntPtr page = PageTable.Page(addr);
PageType pageType = PageTable.Type(page);
if (!PageTable.IsGcPage(pageType))
{
VTable.Assert((PageTable.IsNonGcPage(pageType) &&
PageTable.IsMyPage(page)) ||
PageTable.IsStackPage(pageType));
return;
}
VTable.Assert(PageTable.IsMyPage(page));
Object obj = Magic.fromAddress(addr);
VTable.Assert(IsPossiblyObject(obj), "Bad Object/VTable");
if (obj.GcMark() == UIntPtr.Zero)
{
// The object was not live
*loc = UIntPtr.Zero;
}
}
public static unsafe bool GetSourceInformation(UIntPtr sourceHandle,
UIntPtr *storageHandle,
UIntPtr *eventType,
UInt16 *count,
char *bufferName,
UInt16 bufferSize)
{
UIntPtr tmpStorageHandle = 0;
UIntPtr tmpEventType = 0;
UInt16 tmpCount = 0;
String name = "";
bool success = KernelControllerObject.GetSourceInformation(sourceHandle,
ref tmpStorageHandle,
ref tmpEventType,
ref tmpCount,
ref name);
if (success)
{
*storageHandle = tmpStorageHandle;
*eventType = tmpEventType;
*count = tmpCount;
String.LimitedFormatTo(name, new ArgIterator(), bufferName, bufferSize);
}
return(success);
}
internal unsafe override void Visit(UIntPtr *loc)
{
UIntPtr addr = *loc;
// Ignore pointers out of our memory area
if (PageTable.IsForeignAddr(addr))
{
return;
}
UIntPtr page = PageTable.Page(addr);
PageType pageType = PageTable.Type(page);
if (!PageTable.IsGcPage(pageType))
{
VTable.Assert((PageTable.IsNonGcPage(pageType) &&
PageTable.IsMyPage(page)) ||
PageTable.IsStackPage(pageType));
return;
}
VTable.Assert(PageTable.IsMyPage(page));
Object obj = Magic.fromAddress(addr);
VTable.Assert(IsPossiblyObject(obj), "Bad object/vtable");
if (obj.GcMark((UIntPtr)1))
{
// We changed the color of the object, so we
// have to mark the objects reachable from the fields
workList.Write(addr);
}
}
public void Execute()
{
List <MLight> allSpotLight = MLight.avaliableSpotShadowIndices;
List <MLight> allPointLight = MLight.avaliableCubemapIndices;
UIntPtr * allPtr = stackalloc UIntPtr[max(spotExists ? allSpotLight.Count : 0, pointExists ? allPointLight.Count : 0)];
int ptrCount = 0;
if (spotExists)
{
for (int i = 0; i < allSpotLight.Count; ++i)
{
ref Cone c = ref allSpotLightPosition[i];
float3 dir = c.vertex - cameraPos;
if (!MathLib.ConeIntersect(allSpotLightPosition[i], MathLib.GetPlane(dir, cameraPos + dir * shadowDistance)))
{
allPtr[ptrCount] = new UIntPtr(MUnsafeUtility.GetManagedPtr(allSpotLight[i]));
ptrCount++;
}
}
for (int i = 0; i < ptrCount; ++i)
{
MLight ml = MUnsafeUtility.GetObject <MLight>(allPtr[i].ToPointer());
ml.RemoveLightFromAtlas(false);
ml.updateShadowCache = true;
}
}
internal override unsafe void Visit(UIntPtr *loc)
{
UIntPtr addr = *loc;
UIntPtr page = PageTable.Page(addr);
if (!PageTable.IsGcPage(page))
{
PageType pageType = PageTable.Type(page);
VTable.Assert(pageType == PageType.NonGC ||
pageType == PageType.Stack,
@"pageType == PageType.NonGC ||
pageType == PageType.Stack");
return;
}
UIntPtr objAddr = SegregatedFreeList.Find(addr);
Object obj = Magic.fromAddress(objAddr);
UIntPtr count = getBackupRefcount(obj);
setBackupRefcount(obj, count + 1);
if (obj.GcMark((UIntPtr)1))
{
this.workList.Write(objAddr);
}
}
static void WriteWordNoForward(UIntPtr *ptr,
UIntPtr offset,
UIntPtr mask,
UIntPtr shiftedValue,
bool isObject)
{
if (mask == UIntPtr.MaxValue)
{
if (isObject)
{
TargetBarrierWithForward(*ptr);
}
*ptr = shiftedValue;
}
else
{
for (;;)
{
UIntPtr oldVal = *ptr;
if (CAS(ptr,
(oldVal & ~mask) | (shiftedValue & mask),
oldVal)
== oldVal)
{
return;
}
}
}
}
internal override unsafe void Visit(UIntPtr *loc)
{
UIntPtr objAddr = *loc;
UIntPtr page = PageTable.Page(objAddr);
if (!PageTable.IsGcPage(page))
{
PageType pageType = PageTable.Type(page);
VTable.Assert(pageType == PageType.NonGC ||
pageType == PageType.Stack,
@"pageType == PageType.NonGC ||
pageType == PageType.Stack");
return;
}
Object obj = Magic.fromAddress(objAddr);
if (obj.GcMark((UIntPtr)1))
{
this.time = this.time + 1;
setDfsDiscoveryTime(obj, this.time);
UIntPtr vtableAddr = Magic.addressOf(obj.vtable);
this.Visit(&vtableAddr);
this.VisitReferenceFields(obj);
this.time = this.time + 1;
setDfsFinishingTime(obj, this.time);
}
}
private static int CallSiteSetNumber(UIntPtr returnAddr, int index)
{
UIntPtr codeBaseAddr = codeBaseStartTable[index];
UIntPtr relativeAddr = returnAddr - codeBaseAddr;
UIntPtr *callSiteTable = returnAddressToCallSiteSetNumbers[index];
int callSiteCount = *(callSiteSetCount[index]);
int left = 0;
int right = callSiteCount;
// Loop invariant:
// callSiteTable[left] <= returnAddress < callSiteTable[right]
while (left < right - 1)
{
int mid = (left + right) / 2;
if (callSiteTable[mid] <= relativeAddr)
{
left = mid;
}
else
{
right = mid;
}
}
return(left);
}
internal override unsafe void Visit(UIntPtr *loc)
{
UIntPtr objAddr = *loc;
Object obj = Magic.fromAddress(objAddr);
uint refState = obj.REF_STATE;
if ((refState & countingONFlagMask) == 0)
{
return;
}
uint refCount = refState & refCountMask;
VTable.Assert(refCount > 0,
@"refCount > 0");
refState--;
if ((refState & markFlagMask) != 0)
{
obj.REF_STATE = refState;
}
else
{
obj.REF_STATE = refState | markFlagMask;
this.workList.Write(objAddr);
}
}
internal override unsafe void ProcessObjectPtr(UIntPtr realPtr,
UIntPtr *loc,
UIntPtr addr)
{
// FIXME: DoPin() already does FindObjectForInteriorPtr
CoCoBarrier.instance.DoPin(realPtr, CoCoBarrier.Pinner.StackScan);
}
public unsafe void GetFrameIdentifiers(UIntPtr *identifiersCount, long *identifiers)
{
fixed(cef_browser_t *self = &this)
{
((delegate * unmanaged[Stdcall] < cef_browser_t *, UIntPtr *, long *, void >)get_frame_identifiers)(self, identifiersCount, identifiers);
}
}
public unsafe void SizeOfTest1()
{
UIntPtr *sample = stackalloc UIntPtr[4];
int totalSize = 0;
int ptrSize1 = Marshal.SizeOf(new UIntPtrPointer(sample));
Console.WriteLine("Marshal.SizeOf(new UIntPtrPointer(...)): {0}", ptrSize1);
totalSize += ptrSize1;
int ptrSize2 = Marshal.SizeOf(typeof(UIntPtrPointer));
Console.WriteLine("Marshal.SizeOf(typeof(UIntPtrPointer)): {0}", ptrSize2);
totalSize += ptrSize2;
int ptrSize3 = Marshal.SizeOf(IntPtr.Zero);
Console.WriteLine("Marshal.SizeOf(Intptr.Zero): {0}", ptrSize3);
totalSize += ptrSize3;
int ptrSize4 = Marshal.SizeOf(typeof(IntPtr));
Console.WriteLine("Marshal.SizeOf(typeof(IntPtr)): {0}", ptrSize4);
totalSize += ptrSize4;
int ptrSize5 = Marshal.SizeOf(typeof(UIntPtr *));
Console.WriteLine("Marshal.SizeOf(typeof(UIntPtr*)): {0}", ptrSize5);
totalSize += ptrSize5;
Assert.AreEqual(totalSize, UIntPtrPointer.Size * 5);
}
BOOL IMsoComponentManager.FRegisterComponent(
IMsoComponent component,
MSOCRINFO *pcrinfo,
UIntPtr *pdwComponentID)
{
if (pcrinfo == null || pdwComponentID == null ||
pcrinfo->cbSize < sizeof(MSOCRINFO))
{
return(BOOL.FALSE);
}
// Construct Hashtable entry for this component
ComponentHashtableEntry entry = new ComponentHashtableEntry
{
component = component,
componentInfo = *pcrinfo
};
_cookieCounter += 1;
OleComponents.Add(_cookieCounter, entry);
// Return the cookie
*pdwComponentID = _cookieCounter;
Debug.WriteLineIf(CompModSwitches.MSOComponentManager.TraceInfo, $"ComponentManager: Component registered. ID: {_cookieCounter}");
return(BOOL.TRUE);
}
internal unsafe override void Visit(UIntPtr *loc)
{
UIntPtr addr = *loc;
UIntPtr page = PageTable.Page(addr);
PageType pageType = PageTable.Type(page);
if (!PageTable.IsZombiePage(pageType))
{
VTable.Assert(PageTable.IsGcPage(pageType) ||
PageTable.IsNonGcPage(pageType) ||
PageTable.IsStackPage(pageType) ||
PageTable.IsSharedPage(pageType),
"Semispace:ForwardOnlyReferenceVisitor");
return;
}
PageType gen = PageTable.ZombieToLive(pageType);
UIntPtr vtableAddr = Allocator.GetObjectVTable(addr);
UIntPtr vtablePageIndex = PageTable.Page(vtableAddr);
if (PageTable.Type(vtablePageIndex) == gen)
{
// The vtable field is really a forwarding pointer
*loc = vtableAddr;
}
else
{
// The object was not live
*loc = UIntPtr.Zero;
}
}
