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; } }