Skip to content

Commit c275f4b

Browse files
noahfalknoahfalk
committed
Code review feedback - Renaming fields using m_ style
1 parent e1771be commit c275f4b

17 files changed

+62
-62
lines changed

‎src/coreclr/debug/daccess/dacdbiimpl.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6518,7 +6518,7 @@ HRESULT DacHeapWalker::Init(CORDB_ADDRESS start, CORDB_ADDRESS end)
65186518
j++;
65196519
}
65206520
}
6521-
gc_alloc_context globalCtx = ((ee_alloc_context)g_global_alloc_context).gc_allocation_context;
6521+
gc_alloc_context globalCtx = ((ee_alloc_context)g_global_alloc_context).m_GCAllocContext;
65226522
if (globalCtx.alloc_ptr != nullptr)
65236523
{
65246524
mAllocInfo[j].Ptr = (CORDB_ADDRESS)globalCtx.alloc_ptr;

‎src/coreclr/debug/daccess/request.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5351,7 +5351,7 @@ HRESULT ClrDataAccess::GetGlobalAllocationContext(
53515351
}
53525352

53535353
SOSDacEnter();
5354-
gc_alloc_context global_alloc_context = ((ee_alloc_context)g_global_alloc_context).gc_allocation_context;
5354+
gc_alloc_context global_alloc_context = ((ee_alloc_context)g_global_alloc_context).m_GCAllocContext;
53555355
*allocPtr = (CLRDATA_ADDRESS)global_alloc_context.alloc_ptr;
53565356
*allocLimit = (CLRDATA_ADDRESS)global_alloc_context.alloc_limit;
53575357
SOSDacLeave();

‎src/coreclr/debug/runtimeinfo/datadescriptor.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -139,7 +139,7 @@ CDAC_TYPE_END(RuntimeThreadLocals)
139139

140140
CDAC_TYPE_BEGIN(EEAllocContext)
141141
CDAC_TYPE_INDETERMINATE(EEAllocContext)
142-
CDAC_TYPE_FIELD(EEAllocContext, /*GCAllocContext*/, GCAllocationContext, offsetof(ee_alloc_context, gc_allocation_context))
142+
CDAC_TYPE_FIELD(EEAllocContext, /*GCAllocContext*/, GCAllocationContext, offsetof(ee_alloc_context, m_GCAllocContext))
143143
CDAC_TYPE_END(EEAllocContext)
144144

145145
CDAC_TYPE_BEGIN(GCAllocContext)

‎src/coreclr/vm/amd64/JitHelpers_Slow.asm

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -178,8 +178,8 @@ LEAF_ENTRY JIT_TrialAllocSFastSP, _TEXT
178178
inc [g_global_alloc_lock]
179179
jnz JIT_NEW
180180

181-
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
182-
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
181+
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
182+
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit
183183

184184
add r8, rax
185185

@@ -206,8 +206,8 @@ NESTED_ENTRY JIT_BoxFastUP, _TEXT
206206
inc [g_global_alloc_lock]
207207
jnz JIT_Box
208208

209-
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
210-
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
209+
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
210+
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit
211211

212212
add r8, rax
213213

@@ -285,8 +285,8 @@ LEAF_ENTRY AllocateStringFastUP, _TEXT
285285
inc [g_global_alloc_lock]
286286
jnz FramedAllocateString
287287

288-
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
289-
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
288+
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
289+
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit
290290

291291
add r8, rax
292292

@@ -341,8 +341,8 @@ LEAF_ENTRY JIT_NewArr1VC_UP, _TEXT
341341
inc [g_global_alloc_lock]
342342
jnz JIT_NewArr1
343343

344-
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
345-
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
344+
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
345+
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit
346346

347347
add r8, rax
348348
jc AllocFailed
@@ -394,8 +394,8 @@ LEAF_ENTRY JIT_NewArr1OBJ_UP, _TEXT
394394
inc [g_global_alloc_lock]
395395
jnz JIT_NewArr1
396396

397-
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
398-
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__combined_limit] ; combined_limit
397+
mov rax, [g_global_alloc_context + OFFSETOF__ee_alloc_context__alloc_ptr] ; alloc_ptr
398+
mov r10, [g_global_alloc_context + OFFSETOF__ee_alloc_context__m_CombinedLimit] ; m_CombinedLimit
399399

400400
add r8, rax
401401

‎src/coreclr/vm/amd64/asmconstants.h

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -112,11 +112,11 @@ ASMCONSTANTS_C_ASSERT(OFFSETOF__Thread__m_pFrame
112112

113113

114114
#define OFFSETOF__ee_alloc_context__alloc_ptr 0x8
115-
ASMCONSTANTS_C_ASSERT(OFFSETOF__ee_alloc_context__alloc_ptr == offsetof(ee_alloc_context, gc_allocation_context) +
115+
ASMCONSTANTS_C_ASSERT(OFFSETOF__ee_alloc_context__alloc_ptr == offsetof(ee_alloc_context, m_GCAllocContext) +
116116
offsetof(gc_alloc_context, alloc_ptr));
117117

118-
#define OFFSETOF__ee_alloc_context__combined_limit 0x0
119-
ASMCONSTANTS_C_ASSERT(OFFSETOF__ee_alloc_context__combined_limit == offsetof(ee_alloc_context, combined_limit));
118+
#define OFFSETOF__ee_alloc_context__m_CombinedLimit 0x0
119+
ASMCONSTANTS_C_ASSERT(OFFSETOF__ee_alloc_context__m_CombinedLimit == offsetof(ee_alloc_context, m_CombinedLimit));
120120

121121
#define OFFSETOF__ThreadExceptionState__m_pCurrentTracker 0x000
122122
ASMCONSTANTS_C_ASSERT(OFFSETOF__ThreadExceptionState__m_pCurrentTracker

‎src/coreclr/vm/comutilnative.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -908,7 +908,7 @@ FCIMPL0(INT64, GCInterface::GetAllocatedBytesForCurrentThread)
908908

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

914914
return currentAllocated;

‎src/coreclr/vm/gccover.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1834,7 +1834,7 @@ void DoGcStress (PCONTEXT regs, NativeCodeVersion nativeCodeVersion)
18341834
// BUG(github #10318) - when not using allocation contexts, the alloc lock
18351835
// must be acquired here. Until fixed, this assert prevents random heap corruption.
18361836
assert(GCHeapUtilities::UseThreadAllocationContexts());
1837-
GCHeapUtilities::GetGCHeap()->StressHeap(&t_runtime_thread_locals.alloc_context.gc_allocation_context);
1837+
GCHeapUtilities::GetGCHeap()->StressHeap(&t_runtime_thread_locals.alloc_context.m_GCAllocContext);
18381838

18391839
// StressHeap can exit early w/o forcing a SuspendEE to trigger the instruction update
18401840
// We can not rely on the return code to determine if the instruction update happened

‎src/coreclr/vm/gcenv.ee.cpp

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -445,7 +445,7 @@ gc_alloc_context * GCToEEInterface::GetAllocContext()
445445
return nullptr;
446446
}
447447

448-
return &t_runtime_thread_locals.alloc_context.gc_allocation_context;
448+
return &t_runtime_thread_locals.alloc_context.m_GCAllocContext;
449449
}
450450

451451
void GCToEEInterface::GcEnumAllocContexts(enum_alloc_context_func* fn, void* param)
@@ -465,25 +465,25 @@ void GCToEEInterface::GcEnumAllocContexts(enum_alloc_context_func* fn, void* par
465465
ee_alloc_context* palloc_context = pThread->GetEEAllocContext();
466466
if (palloc_context != nullptr)
467467
{
468-
gc_alloc_context* ac = &palloc_context->gc_allocation_context;
468+
gc_alloc_context* ac = &palloc_context->m_GCAllocContext;
469469
fn(ac, param);
470470
// The GC may zero the alloc_ptr and alloc_limit fields of AC during enumeration and we need to keep
471-
// combined_limit up-to-date. Note that the GC has multiple threads running this enumeration concurrently
471+
// m_CombinedLimit up-to-date. Note that the GC has multiple threads running this enumeration concurrently
472472
// with no synchronization. If you need to change this code think carefully about how that concurrency
473473
// may affect the results.
474-
if (ac->alloc_limit == 0 && palloc_context->combined_limit != 0)
474+
if (ac->alloc_limit == 0 && palloc_context->m_CombinedLimit != 0)
475475
{
476-
palloc_context->combined_limit = 0;
476+
palloc_context->m_CombinedLimit = 0;
477477
}
478478
}
479479
}
480480
}
481481
else
482482
{
483-
fn(&g_global_alloc_context.gc_allocation_context, param);
484-
if (g_global_alloc_context.gc_allocation_context.alloc_limit == 0 && g_global_alloc_context.combined_limit != 0)
483+
fn(&g_global_alloc_context.m_GCAllocContext, param);
484+
if (g_global_alloc_context.m_GCAllocContext.alloc_limit == 0 && g_global_alloc_context.m_CombinedLimit != 0)
485485
{
486-
g_global_alloc_context.combined_limit = 0;
486+
g_global_alloc_context.m_CombinedLimit = 0;
487487
}
488488
}
489489
}

‎src/coreclr/vm/gcheaputilities.h

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -16,12 +16,12 @@ extern "C" {
1616
// This struct allows adding some state that is only visible to the EE onto the standard gc_alloc_context
1717
struct ee_alloc_context
1818
{
19-
// Any allocation that would overlap combined_limit needs to be handled by the allocation slow path.
20-
// combined_limit is the minimum of:
19+
// Any allocation that would overlap m_CombinedLimit needs to be handled by the allocation slow path.
20+
// m_CombinedLimit is the minimum of:
2121
// - gc_alloc_context.alloc_limit (the end of the current AC)
2222
// - the sampling_limit
2323
//
24-
// In the simple case that randomized sampling is disabled, combined_limit is always equal to alloc_limit.
24+
// In the simple case that randomized sampling is disabled, m_CombinedLimit is always equal to alloc_limit.
2525
//
2626
// There are two different useful interpretations for the sampling_limit. One is to treat the sampling_limit
2727
// as an address and when we allocate an object that overlaps that address we should emit a sampling event.
@@ -32,46 +32,46 @@ struct ee_alloc_context
3232
// flexible to handle those cases.
3333
//
3434
// The sampling limit isn't stored in any separate field explicitly, instead it is implied:
35-
// - if combined_limit == alloc_limit there is no sampled byte in the AC. In the budget interpretation
35+
// - if m_CombinedLimit == alloc_limit there is no sampled byte in the AC. In the budget interpretation
3636
// we can allocate (alloc_limit - alloc_ptr) unsampled bytes. We'll need a new random number after
3737
// that to determine whether future allocated bytes should be sampled.
3838
// This occurs either because the sampling feature is disabled, or because the randomized selection
3939
// of sampled bytes didn't select a byte in this AC.
40-
// - if combined_limit < alloc_limit there is a sample limit in the AC. sample_limit = combined_limit.
41-
uint8_t* combined_limit;
42-
gc_alloc_context gc_allocation_context;
40+
// - if m_CombinedLimit < alloc_limit there is a sample limit in the AC. sample_limit = m_CombinedLimit.
41+
uint8_t* m_CombinedLimit;
42+
gc_alloc_context m_GCAllocContext;
4343

4444
void init()
4545
{
4646
LIMITED_METHOD_CONTRACT;
47-
combined_limit = 0;
48-
gc_allocation_context.init();
47+
m_CombinedLimit = 0;
48+
m_GCAllocContext.init();
4949
}
5050

5151
uint8_t* getCombinedLimit()
5252
{
5353
LIMITED_METHOD_CONTRACT;
54-
return combined_limit;
54+
return m_CombinedLimit;
5555
}
5656

5757
static size_t getAllocPtrFieldOffset()
5858
{
5959
LIMITED_METHOD_CONTRACT;
60-
return offsetof(ee_alloc_context, gc_allocation_context) + offsetof(gc_alloc_context, alloc_ptr);
60+
return offsetof(ee_alloc_context, m_GCAllocContext) + offsetof(gc_alloc_context, alloc_ptr);
6161
}
6262

6363
static size_t getCombinedLimitFieldOffset()
6464
{
6565
LIMITED_METHOD_CONTRACT;
66-
return offsetof(ee_alloc_context, combined_limit);
66+
return offsetof(ee_alloc_context, m_CombinedLimit);
6767
}
6868

69-
// Regenerate the randomized sampling limit and update the combined_limit field.
69+
// Regenerate the randomized sampling limit and update the m_CombinedLimit field.
7070
inline void UpdateCombinedLimit()
7171
{
7272
// The randomized sampling feature is being submitted in stages. At this point the sampling is never
73-
// activated so combined_limit is always equal to alloc_limit.
74-
combined_limit = gc_allocation_context.alloc_limit;
73+
// activated so m_CombinedLimit is always equal to alloc_limit.
74+
m_CombinedLimit = m_GCAllocContext.alloc_limit;
7575
}
7676
};
7777

‎src/coreclr/vm/gchelpers.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -223,17 +223,17 @@ inline Object* Alloc(size_t size, GC_ALLOC_FLAGS flags)
223223
if (GCHeapUtilities::UseThreadAllocationContexts())
224224
{
225225
ee_alloc_context *threadContext = GetThreadEEAllocContext();
226-
GCStress<gc_on_alloc>::MaybeTrigger(&threadContext->gc_allocation_context);
227-
retVal = GCHeapUtilities::GetGCHeap()->Alloc(&threadContext->gc_allocation_context, size, flags);
226+
GCStress<gc_on_alloc>::MaybeTrigger(&threadContext->m_GCAllocContext);
227+
retVal = GCHeapUtilities::GetGCHeap()->Alloc(&threadContext->m_GCAllocContext, size, flags);
228228
threadContext->UpdateCombinedLimit();
229229

230230
}
231231
else
232232
{
233233
GlobalAllocLockHolder holder(&g_global_alloc_lock);
234234
ee_alloc_context *globalContext = &g_global_alloc_context;
235-
GCStress<gc_on_alloc>::MaybeTrigger(&globalContext->gc_allocation_context);
236-
retVal = GCHeapUtilities::GetGCHeap()->Alloc(&globalContext->gc_allocation_context, size, flags);
235+
GCStress<gc_on_alloc>::MaybeTrigger(&globalContext->m_GCAllocContext);
236+
retVal = GCHeapUtilities::GetGCHeap()->Alloc(&globalContext->m_GCAllocContext, size, flags);
237237
globalContext->UpdateCombinedLimit();
238238
}
239239

‎src/coreclr/vm/gcstress.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -298,7 +298,7 @@ namespace _GCStress
298298
// BUG(github #10318) - when not using allocation contexts, the alloc lock
299299
// must be acquired here. Until fixed, this assert prevents random heap corruption.
300300
_ASSERTE(GCHeapUtilities::UseThreadAllocationContexts());
301-
GCHeapUtilities::GetGCHeap()->StressHeap(&t_runtime_thread_locals.alloc_context.gc_allocation_context);
301+
GCHeapUtilities::GetGCHeap()->StressHeap(&t_runtime_thread_locals.alloc_context.m_GCAllocContext);
302302
}
303303

304304
FORCEINLINE

‎src/coreclr/vm/i386/jitinterfacex86.cpp

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -218,7 +218,7 @@ void JIT_TrialAlloc::EmitCore(CPUSTUBLINKER *psl, CodeLabel *noLock, CodeLabel *
218218

219219
if (flags & (ALIGN8 | SIZE_IN_EAX | ALIGN8OBJ))
220220
{
221-
// MOV EBX, [edx]alloc_context.gc_allocation_context.alloc_ptr
221+
// MOV EBX, [edx]alloc_context.m_GCAllocContext.alloc_ptr
222222
psl->X86EmitOffsetModRM(0x8B, kEBX, kEDX, ee_alloc_context::getAllocPtrFieldOffset());
223223
// add EAX, EBX
224224
psl->Emit16(0xC303);
@@ -227,19 +227,19 @@ void JIT_TrialAlloc::EmitCore(CPUSTUBLINKER *psl, CodeLabel *noLock, CodeLabel *
227227
}
228228
else
229229
{
230-
// add eax, [edx]alloc_context.gc_allocation_context.alloc_ptr
230+
// add eax, [edx]alloc_context.m_GCAllocContext.alloc_ptr
231231
psl->X86EmitOffsetModRM(0x03, kEAX, kEDX, ee_alloc_context::getAllocPtrFieldOffset());
232232
}
233233

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

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

240240
// Fill in the allocation and get out.
241241

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

245245
if (flags & (ALIGN8 | SIZE_IN_EAX | ALIGN8OBJ))
@@ -282,7 +282,7 @@ void JIT_TrialAlloc::EmitCore(CPUSTUBLINKER *psl, CodeLabel *noLock, CodeLabel *
282282
psl->X86EmitIndexRegLoad(kEDX, kECX, offsetof(MethodTable, m_BaseSize));
283283
}
284284

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

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

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

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

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

‎src/coreclr/vm/i386/stublinkerx86.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2197,7 +2197,7 @@ namespace
21972197
{
21982198
gc_alloc_context* STDCALL GetAllocContextHelper()
21992199
{
2200-
return &t_runtime_thread_locals.alloc_context.gc_allocation_context;
2200+
return &t_runtime_thread_locals.alloc_context.m_GCAllocContext;
22012201
}
22022202
}
22032203
#endif

‎src/coreclr/vm/jithelpers.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1183,7 +1183,7 @@ HCIMPL1_RAW(Object*, JIT_NewS_MP_FastPortable, CORINFO_CLASS_HANDLE typeHnd_)
11831183

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

11881188
TypeHandle typeHandle(typeHnd_);
11891189
_ASSERTE(!typeHandle.IsTypeDesc()); // heap objects must have method tables
@@ -1301,7 +1301,7 @@ HCIMPL1_RAW(StringObject*, AllocateString_MP_FastPortable, DWORD stringLength)
13011301
}
13021302

13031303
ee_alloc_context *eeAllocContext = &t_runtime_thread_locals.alloc_context;
1304-
gc_alloc_context *allocContext = &eeAllocContext->gc_allocation_context;
1304+
gc_alloc_context *allocContext = &eeAllocContext->m_GCAllocContext;
13051305

13061306
SIZE_T totalSize = StringObject::GetSize(stringLength);
13071307

@@ -1418,7 +1418,7 @@ HCIMPL2_RAW(Object*, JIT_NewArr1VC_MP_FastPortable, CORINFO_CLASS_HANDLE arrayMT
14181418
}
14191419

14201420
ee_alloc_context* eeAllocContext = &t_runtime_thread_locals.alloc_context;
1421-
gc_alloc_context* allocContext = &eeAllocContext->gc_allocation_context;
1421+
gc_alloc_context* allocContext = &eeAllocContext->m_GCAllocContext;
14221422

14231423
MethodTable *pArrayMT = (MethodTable *)arrayMT;
14241424

@@ -1488,7 +1488,7 @@ HCIMPL2_RAW(Object*, JIT_NewArr1OBJ_MP_FastPortable, CORINFO_CLASS_HANDLE arrayM
14881488
_ASSERTE(ALIGN_UP(totalSize, DATA_ALIGNMENT) == totalSize);
14891489

14901490
ee_alloc_context* eeAllocContext = &t_runtime_thread_locals.alloc_context;
1491-
gc_alloc_context* allocContext = &eeAllocContext->gc_allocation_context;
1491+
gc_alloc_context* allocContext = &eeAllocContext->m_GCAllocContext;
14921492
BYTE *allocPtr = allocContext->alloc_ptr;
14931493
_ASSERTE(allocPtr <= eeAllocContext->getCombinedLimit());
14941494
if (totalSize > static_cast<SIZE_T>(eeAllocContext->getCombinedLimit() - allocPtr))
@@ -1639,7 +1639,7 @@ HCIMPL2_RAW(Object*, JIT_Box_MP_FastPortable, CORINFO_CLASS_HANDLE type, void* u
16391639

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

16441644
TypeHandle typeHandle(type);
16451645
_ASSERTE(!typeHandle.IsTypeDesc()); // heap objects must have method tables

0 commit comments

Comments
 (0)