Skip to content

Commit

Permalink
Code review feedback - Renaming fields using m_ style
Browse files Browse the repository at this point in the history
  • Loading branch information
@noahfalk
noahfalk committed Jul 30, 2024
1 parent b4d8ba7 commit cd70d74
Show file tree
Hide file tree
Showing 17 changed files with 62 additions and 62 deletions.
2 changes: 1 addition & 1 deletion src/coreclr/debug/daccess/dacdbiimpl.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6554,7 +6554,7 @@ HRESULT DacHeapWalker::Init(CORDB_ADDRESS start, CORDB_ADDRESS end)
j++;
}
}
gc_alloc_context globalCtx = ((ee_alloc_context)g_global_alloc_context).gc_allocation_context;
gc_alloc_context globalCtx = ((ee_alloc_context)g_global_alloc_context).m_GCAllocContext;
if (globalCtx.alloc_ptr != nullptr)
{
mAllocInfo[j].Ptr = (CORDB_ADDRESS)globalCtx.alloc_ptr;
Expand Down
2 changes: 1 addition & 1 deletion src/coreclr/debug/daccess/request.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5767,7 +5767,7 @@ HRESULT ClrDataAccess::GetGlobalAllocationContext(
}

SOSDacEnter();
gc_alloc_context global_alloc_context = ((ee_alloc_context)g_global_alloc_context).gc_allocation_context;
gc_alloc_context global_alloc_context = ((ee_alloc_context)g_global_alloc_context).m_GCAllocContext;
*allocPtr = (CLRDATA_ADDRESS)global_alloc_context.alloc_ptr;
*allocLimit = (CLRDATA_ADDRESS)global_alloc_context.alloc_limit;
SOSDacLeave();
Expand Down
2 changes: 1 addition & 1 deletion src/coreclr/debug/runtimeinfo/datadescriptor.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -137,7 +137,7 @@ CDAC_TYPE_END(RuntimeThreadLocals)

CDAC_TYPE_BEGIN(EEAllocContext)
CDAC_TYPE_INDETERMINATE(EEAllocContext)
CDAC_TYPE_FIELD(EEAllocContext, /*GCAllocContext*/, GCAllocationContext, offsetof(ee_alloc_context, gc_allocation_context))
CDAC_TYPE_FIELD(EEAllocContext, /*GCAllocContext*/, GCAllocationContext, offsetof(ee_alloc_context, m_GCAllocContext))
CDAC_TYPE_END(EEAllocContext)

CDAC_TYPE_BEGIN(GCAllocContext)
Expand Down
20 changes: 10 additions & 10 deletions src/coreclr/vm/amd64/JitHelpers_Slow.asm
View file
Original file line number Diff line number Diff line change
Expand Up @@ -180,8 +180,8 @@ LEAF_ENTRY JIT_TrialAllocSFastSP, _TEXT
inc [g_global_alloc_lock]
jnz JIT_NEW

mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit

add r8, rax

Expand All @@ -208,8 +208,8 @@ NESTED_ENTRY JIT_BoxFastUP, _TEXT
inc [g_global_alloc_lock]
jnz JIT_Box

mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit

add r8, rax

Expand Down Expand Up @@ -287,8 +287,8 @@ LEAF_ENTRY AllocateStringFastUP, _TEXT
inc [g_global_alloc_lock]
jnz FramedAllocateString

mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit

add r8, rax

Expand Down Expand Up @@ -343,8 +343,8 @@ LEAF_ENTRY JIT_NewArr1VC_UP, _TEXT
inc [g_global_alloc_lock]
jnz JIT_NewArr1

mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit

add r8, rax
jc AllocFailed
Expand Down Expand Up @@ -396,8 +396,8 @@ LEAF_ENTRY JIT_NewArr1OBJ_UP, _TEXT
inc [g_global_alloc_lock]
jnz JIT_NewArr1

mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit

add r8, rax

Expand Down
6 changes: 3 additions & 3 deletions src/coreclr/vm/amd64/asmconstants.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -112,11 +112,11 @@ ASMCONSTANTS_C_ASSERT(OFFSETOF__Thread__m_pFrame


#define OFFSETOF__ee_alloc_context__alloc_ptr 0x8
ASMCONSTANTS_C_ASSERT(OFFSETOF__ee_alloc_context__alloc_ptr == offsetof(ee_alloc_context, gc_allocation_context) +
ASMCONSTANTS_C_ASSERT(OFFSETOF__ee_alloc_context__alloc_ptr == offsetof(ee_alloc_context, m_GCAllocContext) +
offsetof(gc_alloc_context, alloc_ptr));

#define OFFSETOF__ee_alloc_context__combined_limit 0x0
ASMCONSTANTS_C_ASSERT(OFFSETOF__ee_alloc_context__combined_limit == offsetof(ee_alloc_context, combined_limit));
#define OFFSETOF__ee_alloc_context__m_CombinedLimit 0x0
ASMCONSTANTS_C_ASSERT(OFFSETOF__ee_alloc_context__m_CombinedLimit == offsetof(ee_alloc_context, m_CombinedLimit));

#define OFFSETOF__ThreadExceptionState__m_pCurrentTracker 0x000
ASMCONSTANTS_C_ASSERT(OFFSETOF__ThreadExceptionState__m_pCurrentTracker
Expand Down
2 changes: 1 addition & 1 deletion src/coreclr/vm/comutilnative.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -889,7 +889,7 @@ FCIMPL0(INT64, GCInterface::GetAllocatedBytesForCurrentThread)

INT64 currentAllocated = 0;
Thread *pThread = GetThread();
gc_alloc_context* ac = &t_runtime_thread_locals.alloc_context.gc_allocation_context;
gc_alloc_context* ac = &t_runtime_thread_locals.alloc_context.m_GCAllocContext;
currentAllocated = ac->alloc_bytes + ac->alloc_bytes_uoh - (ac->alloc_limit - ac->alloc_ptr);

return currentAllocated;
Expand Down
2 changes: 1 addition & 1 deletion src/coreclr/vm/gccover.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1834,7 +1834,7 @@ void DoGcStress (PCONTEXT regs, NativeCodeVersion nativeCodeVersion)
// BUG(github #10318) - when not using allocation contexts, the alloc lock
// must be acquired here. Until fixed, this assert prevents random heap corruption.
assert(GCHeapUtilities::UseThreadAllocationContexts());
GCHeapUtilities::GetGCHeap()->StressHeap(&t_runtime_thread_locals.alloc_context.gc_allocation_context);
GCHeapUtilities::GetGCHeap()->StressHeap(&t_runtime_thread_locals.alloc_context.m_GCAllocContext);

// StressHeap can exit early w/o forcing a SuspendEE to trigger the instruction update
// We can not rely on the return code to determine if the instruction update happened
Expand Down
16 changes: 8 additions & 8 deletions src/coreclr/vm/gcenv.ee.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -443,7 +443,7 @@ gc_alloc_context * GCToEEInterface::GetAllocContext()
return nullptr;
}

return &t_runtime_thread_locals.alloc_context.gc_allocation_context;
return &t_runtime_thread_locals.alloc_context.m_GCAllocContext;
}

void GCToEEInterface::GcEnumAllocContexts(enum_alloc_context_func* fn, void* param)
Expand All @@ -463,25 +463,25 @@ void GCToEEInterface::GcEnumAllocContexts(enum_alloc_context_func* fn, void* par
ee_alloc_context* palloc_context = pThread->GetEEAllocContext();
if (palloc_context != nullptr)
{
gc_alloc_context* ac = &palloc_context->gc_allocation_context;
gc_alloc_context* ac = &palloc_context->m_GCAllocContext;
fn(ac, param);
// The GC may zero the alloc_ptr and alloc_limit fields of AC during enumeration and we need to keep
// combined_limit up-to-date. Note that the GC has multiple threads running this enumeration concurrently
// m_CombinedLimit up-to-date. Note that the GC has multiple threads running this enumeration concurrently
// with no synchronization. If you need to change this code think carefully about how that concurrency
// may affect the results.
if (ac->alloc_limit == 0 && palloc_context->combined_limit != 0)
if (ac->alloc_limit == 0 && palloc_context->m_CombinedLimit != 0)
{
palloc_context->combined_limit = 0;
palloc_context->m_CombinedLimit = 0;
}
}
}
}
else
{
fn(&g_global_alloc_context.gc_allocation_context, param);
if (g_global_alloc_context.gc_allocation_context.alloc_limit == 0 && g_global_alloc_context.combined_limit != 0)
fn(&g_global_alloc_context.m_GCAllocContext, param);
if (g_global_alloc_context.m_GCAllocContext.alloc_limit == 0 && g_global_alloc_context.m_CombinedLimit != 0)
{
g_global_alloc_context.combined_limit = 0;
g_global_alloc_context.m_CombinedLimit = 0;
}
}
}
Expand Down
30 changes: 15 additions & 15 deletions src/coreclr/vm/gcheaputilities.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,12 +16,12 @@ extern "C" {
// This struct allows adding some state that is only visible to the EE onto the standard gc_alloc_context
struct ee_alloc_context
{
// Any allocation that would overlap combined_limit needs to be handled by the allocation slow path.
// combined_limit is the minimum of:
// Any allocation that would overlap m_CombinedLimit needs to be handled by the allocation slow path.
// m_CombinedLimit is the minimum of:
// - gc_alloc_context.alloc_limit (the end of the current AC)
// - the sampling_limit
//
// In the simple case that randomized sampling is disabled, combined_limit is always equal to alloc_limit.
// In the simple case that randomized sampling is disabled, m_CombinedLimit is always equal to alloc_limit.
//
// There are two different useful interpretations for the sampling_limit. One is to treat the sampling_limit
// as an address and when we allocate an object that overlaps that address we should emit a sampling event.
Expand All @@ -32,46 +32,46 @@ struct ee_alloc_context
// flexible to handle those cases.
//
// The sampling limit isn't stored in any separate field explicitly, instead it is implied:
// - if combined_limit == alloc_limit there is no sampled byte in the AC. In the budget interpretation
// - if m_CombinedLimit == alloc_limit there is no sampled byte in the AC. In the budget interpretation
// we can allocate (alloc_limit - alloc_ptr) unsampled bytes. We'll need a new random number after
// that to determine whether future allocated bytes should be sampled.
// This occurs either because the sampling feature is disabled, or because the randomized selection
// of sampled bytes didn't select a byte in this AC.
// - if combined_limit < alloc_limit there is a sample limit in the AC. sample_limit = combined_limit.
uint8_t* combined_limit;
gc_alloc_context gc_allocation_context;
// - if m_CombinedLimit < alloc_limit there is a sample limit in the AC. sample_limit = m_CombinedLimit.
uint8_t* m_CombinedLimit;
gc_alloc_context m_GCAllocContext;

void init()
{
LIMITED_METHOD_CONTRACT;
combined_limit = 0;
gc_allocation_context.init();
m_CombinedLimit = 0;
m_GCAllocContext.init();
}

uint8_t* getCombinedLimit()
{
LIMITED_METHOD_CONTRACT;
return combined_limit;
return m_CombinedLimit;
}

static size_t getAllocPtrFieldOffset()
{
LIMITED_METHOD_CONTRACT;
return offsetof(ee_alloc_context, gc_allocation_context) + offsetof(gc_alloc_context, alloc_ptr);
return offsetof(ee_alloc_context, m_GCAllocContext) + offsetof(gc_alloc_context, alloc_ptr);
}

static size_t getCombinedLimitFieldOffset()
{
LIMITED_METHOD_CONTRACT;
return offsetof(ee_alloc_context, combined_limit);
return offsetof(ee_alloc_context, m_CombinedLimit);
}

// Regenerate the randomized sampling limit and update the combined_limit field.
// Regenerate the randomized sampling limit and update the m_CombinedLimit field.
inline void UpdateCombinedLimit()
{
// The randomized sampling feature is being submitted in stages. At this point the sampling is never
// activated so combined_limit is always equal to alloc_limit.
combined_limit = gc_allocation_context.alloc_limit;
// activated so m_CombinedLimit is always equal to alloc_limit.
m_CombinedLimit = m_GCAllocContext.alloc_limit;
}
};

Expand Down
8 changes: 4 additions & 4 deletions src/coreclr/vm/gchelpers.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -223,17 +223,17 @@ inline Object* Alloc(size_t size, GC_ALLOC_FLAGS flags)
if (GCHeapUtilities::UseThreadAllocationContexts())
{
ee_alloc_context *threadContext = GetThreadEEAllocContext();
GCStress<gc_on_alloc>::MaybeTrigger(&threadContext->gc_allocation_context);
retVal = GCHeapUtilities::GetGCHeap()->Alloc(&threadContext->gc_allocation_context, size, flags);
GCStress<gc_on_alloc>::MaybeTrigger(&threadContext->m_GCAllocContext);
retVal = GCHeapUtilities::GetGCHeap()->Alloc(&threadContext->m_GCAllocContext, size, flags);
threadContext->UpdateCombinedLimit();

}
else
{
GlobalAllocLockHolder holder(&g_global_alloc_lock);
ee_alloc_context *globalContext = &g_global_alloc_context;
GCStress<gc_on_alloc>::MaybeTrigger(&globalContext->gc_allocation_context);
retVal = GCHeapUtilities::GetGCHeap()->Alloc(&globalContext->gc_allocation_context, size, flags);
GCStress<gc_on_alloc>::MaybeTrigger(&globalContext->m_GCAllocContext);
retVal = GCHeapUtilities::GetGCHeap()->Alloc(&globalContext->m_GCAllocContext, size, flags);
globalContext->UpdateCombinedLimit();
}

Expand Down
2 changes: 1 addition & 1 deletion src/coreclr/vm/gcstress.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -298,7 +298,7 @@ namespace _GCStress
// BUG(github #10318) - when not using allocation contexts, the alloc lock
// must be acquired here. Until fixed, this assert prevents random heap corruption.
_ASSERTE(GCHeapUtilities::UseThreadAllocationContexts());
GCHeapUtilities::GetGCHeap()->StressHeap(&t_runtime_thread_locals.alloc_context.gc_allocation_context);
GCHeapUtilities::GetGCHeap()->StressHeap(&t_runtime_thread_locals.alloc_context.m_GCAllocContext);
}

FORCEINLINE
Expand Down
14 changes: 7 additions & 7 deletions src/coreclr/vm/i386/jitinterfacex86.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -237,7 +237,7 @@ void JIT_TrialAlloc::EmitCore(CPUSTUBLINKER *psl, CodeLabel *noLock, CodeLabel *

if (flags & (ALIGN8 | SIZE_IN_EAX | ALIGN8OBJ))
{
// MOV EBX, [edx]alloc_context.gc_allocation_context.alloc_ptr
// MOV EBX, [edx]alloc_context.m_GCAllocContext.alloc_ptr
psl->X86EmitOffsetModRM(0x8B, kEBX, kEDX, ee_alloc_context::getAllocPtrFieldOffset());
// add EAX, EBX
psl->Emit16(0xC303);
Expand All @@ -246,19 +246,19 @@ void JIT_TrialAlloc::EmitCore(CPUSTUBLINKER *psl, CodeLabel *noLock, CodeLabel *
}
else
{
// add eax, [edx]alloc_context.gc_allocation_context.alloc_ptr
// add eax, [edx]alloc_context.m_GCAllocContext.alloc_ptr
psl->X86EmitOffsetModRM(0x03, kEAX, kEDX, ee_alloc_context::getAllocPtrFieldOffset());
}

// cmp eax, [edx]alloc_context.combined_limit
// cmp eax, [edx]alloc_context.m_CombinedLimit
psl->X86EmitOffsetModRM(0x3b, kEAX, kEDX, ee_alloc_context::getCombinedLimitFieldOffset());

// ja noAlloc
psl->X86EmitCondJump(noAlloc, X86CondCode::kJA);

// Fill in the allocation and get out.

// mov [edx]alloc_context.gc_allocation_context.alloc_ptr, eax
// mov [edx]alloc_context.m_GCAllocContext.alloc_ptr, eax
psl->X86EmitIndexRegStore(kEDX, ee_alloc_context::getAllocPtrFieldOffset(), kEAX);

if (flags & (ALIGN8 | SIZE_IN_EAX | ALIGN8OBJ))
Expand Down Expand Up @@ -301,7 +301,7 @@ void JIT_TrialAlloc::EmitCore(CPUSTUBLINKER *psl, CodeLabel *noLock, CodeLabel *
psl->X86EmitIndexRegLoad(kEDX, kECX, offsetof(MethodTable, m_BaseSize));
}

// mov eax, dword ptr [g_global_alloc_context.gc_allocation_context.alloc_ptr]
// mov eax, dword ptr [g_global_alloc_context.m_GCAllocContext.alloc_ptr]
psl->Emit8(0xA1);
psl->Emit32((int)(size_t)&g_global_alloc_context + ee_alloc_context::getAllocPtrFieldOffset());

Expand All @@ -312,15 +312,15 @@ void JIT_TrialAlloc::EmitCore(CPUSTUBLINKER *psl, CodeLabel *noLock, CodeLabel *
if (flags & (ALIGN8 | ALIGN8OBJ))
EmitAlignmentRoundup(psl, kEAX, kEDX, flags); // bump up EDX size by 12 if EAX unaligned (so that we are aligned)

// cmp edx, dword ptr [g_global_alloc_context.combined_limit]
// cmp edx, dword ptr [g_global_alloc_context.m_CombinedLimit]
psl->Emit16(0x153b);
psl->Emit32((int)(size_t)&g_global_alloc_context + ee_alloc_context::getCombinedLimitFieldOffset());

// ja noAlloc
psl->X86EmitCondJump(noAlloc, X86CondCode::kJA);

// Fill in the allocation and get out.
// mov dword ptr [g_global_alloc_context.gc_allocation_context.alloc_ptr], edx
// mov dword ptr [g_global_alloc_context.m_GCAllocContext.alloc_ptr], edx
psl->Emit16(0x1589);
psl->Emit32((int)(size_t)&g_global_alloc_context + ee_alloc_context::getAllocPtrFieldOffset());

Expand Down
2 changes: 1 addition & 1 deletion src/coreclr/vm/i386/stublinkerx86.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2434,7 +2434,7 @@ namespace
{
gc_alloc_context* STDCALL GetAllocContextHelper()
{
return &t_runtime_thread_locals.alloc_context.gc_allocation_context;
return &t_runtime_thread_locals.alloc_context.m_GCAllocContext;
}
}
#endif
Expand Down
10 changes: 5 additions & 5 deletions src/coreclr/vm/jithelpers.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1213,7 +1213,7 @@ HCIMPL1_RAW(Object*, JIT_NewS_MP_FastPortable, CORINFO_CLASS_HANDLE typeHnd_)

_ASSERTE(GCHeapUtilities::UseThreadAllocationContexts());
ee_alloc_context *eeAllocContext = &t_runtime_thread_locals.alloc_context;
gc_alloc_context *allocContext = &eeAllocContext->gc_allocation_context;
gc_alloc_context *allocContext = &eeAllocContext->m_GCAllocContext;

TypeHandle typeHandle(typeHnd_);
_ASSERTE(!typeHandle.IsTypeDesc()); // heap objects must have method tables
Expand Down Expand Up @@ -1331,7 +1331,7 @@ HCIMPL1_RAW(StringObject*, AllocateString_MP_FastPortable, DWORD stringLength)
}

ee_alloc_context *eeAllocContext = &t_runtime_thread_locals.alloc_context;
gc_alloc_context *allocContext = &eeAllocContext->gc_allocation_context;
gc_alloc_context *allocContext = &eeAllocContext->m_GCAllocContext;

SIZE_T totalSize = StringObject::GetSize(stringLength);

Expand Down Expand Up @@ -1448,7 +1448,7 @@ HCIMPL2_RAW(Object*, JIT_NewArr1VC_MP_FastPortable, CORINFO_CLASS_HANDLE arrayMT
}

ee_alloc_context* eeAllocContext = &t_runtime_thread_locals.alloc_context;
gc_alloc_context* allocContext = &eeAllocContext->gc_allocation_context;
gc_alloc_context* allocContext = &eeAllocContext->m_GCAllocContext;

MethodTable *pArrayMT = (MethodTable *)arrayMT;

Expand Down Expand Up @@ -1518,7 +1518,7 @@ HCIMPL2_RAW(Object*, JIT_NewArr1OBJ_MP_FastPortable, CORINFO_CLASS_HANDLE arrayM
_ASSERTE(ALIGN_UP(totalSize, DATA_ALIGNMENT) == totalSize);

ee_alloc_context* eeAllocContext = &t_runtime_thread_locals.alloc_context;
gc_alloc_context* allocContext = &eeAllocContext->gc_allocation_context;
gc_alloc_context* allocContext = &eeAllocContext->m_GCAllocContext;
BYTE *allocPtr = allocContext->alloc_ptr;
_ASSERTE(allocPtr <= eeAllocContext->getCombinedLimit());
if (totalSize > static_cast<SIZE_T>(eeAllocContext->getCombinedLimit() - allocPtr))
Expand Down Expand Up @@ -1669,7 +1669,7 @@ HCIMPL2_RAW(Object*, JIT_Box_MP_FastPortable, CORINFO_CLASS_HANDLE type, void* u

_ASSERTE(GCHeapUtilities::UseThreadAllocationContexts());
ee_alloc_context* eeAllocContext = &t_runtime_thread_locals.alloc_context;
gc_alloc_context* allocContext = &eeAllocContext->gc_allocation_context;
gc_alloc_context* allocContext = &eeAllocContext->m_GCAllocContext;

TypeHandle typeHandle(type);
_ASSERTE(!typeHandle.IsTypeDesc()); // heap objects must have method tables
Expand Down
Loading

0 comments on commit cd70d74

Please sign in to comment.