Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 2 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

195 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

227 lines

LEAF_ENTRY JIT_ByRefWriteBarrier, _TEXT

LEAF_ENTRY JIT_ByRefWriteBarrierBatch, _TEXT

LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch):

mov rcx, [rsi]

// If !WRITE_BARRIER_CHECK do the write first, otherwise we might have to do some ShadowGC stuff

#ifndef WRITE_BARRIER_CHECK

// rcx is [rsi]

mov [rdi], rcx

#endif

// When WRITE_BARRIER_CHECK is defined _NotInHeap will write the reference

// but if it isn't then it will just return.

// See if this is in GCHeap

PREPARE_EXTERNAL_VAR g_lowest_address, rax

cmp rdi, [rax]

jb LOCAL_LABEL(NotInHeap_ByRefWriteBarrier)

jb LOCAL_LABEL(NotInHeap_ByRefWriteBarrierBatch)

PREPARE_EXTERNAL_VAR g_highest_address, rax

cmp rdi, [rax]

jnb LOCAL_LABEL(NotInHeap_ByRefWriteBarrier)

jnb LOCAL_LABEL(NotInHeap_ByRefWriteBarrierBatch)

#ifdef WRITE_BARRIER_CHECK

// **ALSO update the shadow GC heap if that is enabled**

// Do not perform the work if g_GCShadow is 0

PREPARE_EXTERNAL_VAR g_GCShadow, rax

cmp qword ptr [rax], 0

je LOCAL_LABEL(NoShadow_ByRefWriteBarrier)

je LOCAL_LABEL(NoShadow_ByRefWriteBarrierBatch)

// If we end up outside of the heap don't corrupt random memory

mov r10, rdi

PREPARE_EXTERNAL_VAR g_lowest_address, rax

sub r10, [rax]

jb LOCAL_LABEL(NoShadow_ByRefWriteBarrier)

jb LOCAL_LABEL(NoShadow_ByRefWriteBarrierBatch)

// Check that our adjusted destination is somewhere in the shadow gc

PREPARE_EXTERNAL_VAR g_GCShadow, rax

add r10, [rax]

PREPARE_EXTERNAL_VAR g_GCShadowEnd, rax

cmp r10, [rax]

jnb LOCAL_LABEL(NoShadow_ByRefWriteBarrier)

jnb LOCAL_LABEL(NoShadow_ByRefWriteBarrierBatch)

// Write ref into real GC

mov [rdi], rcx

// Write ref into shadow GC

mov [r10], rcx

// Ensure that the write to the shadow heap occurs before the read from

// the GC heap so that race conditions are caught by INVALIDGCVALUE

mfence

// Check that GC/ShadowGC values match

mov r11, [rdi]

mov rax, [r10]

cmp rax, r11

je LOCAL_LABEL(DoneShadow_ByRefWriteBarrier)

je LOCAL_LABEL(DoneShadow_ByRefWriteBarrierBatch)

movabs r11, INVALIDGCVALUE

mov [r10], r11

jmp LOCAL_LABEL(DoneShadow_ByRefWriteBarrier)

jmp LOCAL_LABEL(DoneShadow_ByRefWriteBarrierBatch)

// If we don't have a shadow GC we won't have done the write yet

LOCAL_LABEL(NoShadow_ByRefWriteBarrier):

LOCAL_LABEL(NoShadow_ByRefWriteBarrierBatch):

mov [rdi], rcx

// If we had a shadow GC then we already wrote to the real GC at the same time

// as the shadow GC so we want to jump over the real write immediately above.

// Additionally we know for sure that we are inside the heap and therefore don't

// need to replicate the above checks.

LOCAL_LABEL(DoneShadow_ByRefWriteBarrier):

LOCAL_LABEL(DoneShadow_ByRefWriteBarrierBatch):

#endif

#ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP

// Update the write watch table if necessary

PREPARE_EXTERNAL_VAR g_sw_ww_enabled_for_gc_heap, rax

cmp byte ptr [rax], 0x0

je LOCAL_LABEL(CheckCardTable_ByRefWriteBarrier)

je LOCAL_LABEL(CheckCardTable_ByRefWriteBarrierBatch)

mov rax, rdi

shr rax, 0xC // SoftwareWriteWatch::AddressToTableByteIndexShift

PREPARE_EXTERNAL_VAR g_sw_ww_table, r10

add rax, qword ptr [r10]

cmp byte ptr [rax], 0x0

jne LOCAL_LABEL(CheckCardTable_ByRefWriteBarrier)

jne LOCAL_LABEL(CheckCardTable_ByRefWriteBarrierBatch)

mov byte ptr [rax], 0xFF

#endif

LOCAL_LABEL(CheckCardTable_ByRefWriteBarrier):

LOCAL_LABEL(CheckCardTable_ByRefWriteBarrierBatch):

// See if we can just quick out

PREPARE_EXTERNAL_VAR g_ephemeral_low, rax

cmp rcx, [rax]

jb LOCAL_LABEL(Exit_ByRefWriteBarrier)

jb LOCAL_LABEL(Exit_ByRefWriteBarrierBatch)

PREPARE_EXTERNAL_VAR g_ephemeral_high, rax

cmp rcx, [rax]

jnb LOCAL_LABEL(Exit_ByRefWriteBarrier)

jnb LOCAL_LABEL(Exit_ByRefWriteBarrierBatch)

mov rax, rcx

PREPARE_EXTERNAL_VAR g_region_shr, rcx

mov cl, [rcx]

test cl, cl

je LOCAL_LABEL(SkipCheck_ByRefWriteBarrier)

je LOCAL_LABEL(SkipCheck_ByRefWriteBarrierBatch)

// check if the source is in gen 2 - then it's not an ephemeral pointer

shr rax, cl

PREPARE_EXTERNAL_VAR g_region_to_generation_table, r10

mov r10, [r10]

cmp byte ptr [rax + r10], 0x82

je LOCAL_LABEL(Exit_ByRefWriteBarrier)

je LOCAL_LABEL(Exit_ByRefWriteBarrierBatch)

// check if the destination happens to be in gen 0

mov rax, rdi

shr rax, cl

cmp byte ptr [rax + r10], 0

je LOCAL_LABEL(Exit_ByRefWriteBarrier)

je LOCAL_LABEL(Exit_ByRefWriteBarrierBatch)

LOCAL_LABEL(SkipCheck_ByRefWriteBarrier):

LOCAL_LABEL(SkipCheck_ByRefWriteBarrierBatch):

PREPARE_EXTERNAL_VAR g_card_table, r10

mov r10, [r10]

PREPARE_EXTERNAL_VAR g_region_use_bitwise_write_barrier, rax

cmp byte ptr [rax], 0

je LOCAL_LABEL(CheckCardTableByte_ByRefWriteBarrier)

je LOCAL_LABEL(CheckCardTableByte_ByRefWriteBarrierBatch)

// compute card table bit

mov ecx, edi

mov al, 1

shr ecx, 8

and cl, 7

shl al, cl

// move current rdi value into rcx and then increment the pointers

mov rcx, rdi

add rsi, 0x8

add rdi, 0x8

// Check if we need to update the card table

// Calc pCardByte

shr rcx, 0xB

// Check if this card table bit is already set

test byte ptr [rcx + r10], al

je LOCAL_LABEL(SetCardTableBit_ByRefWriteBarrier)

je LOCAL_LABEL(SetCardTableBit_ByRefWriteBarrierBatch)

// Check if we have more in the batch and run again

dec r8d

jne LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)

REPRET

LOCAL_LABEL(SetCardTableBit_ByRefWriteBarrier):

LOCAL_LABEL(SetCardTableBit_ByRefWriteBarrierBatch):

lock or byte ptr [rcx + r10], al

jmp LOCAL_LABEL(CheckCardBundle_ByRefWriteBarrier)

jmp LOCAL_LABEL(CheckCardBundle_ByRefWriteBarrierBatch)

LOCAL_LABEL(CheckCardTableByte_ByRefWriteBarrier):

LOCAL_LABEL(CheckCardTableByte_ByRefWriteBarrierBatch):

// move current rdi value into rcx and then increment the pointers

mov rcx, rdi

add rsi, 0x8

add rdi, 0x8

shr rcx, 0xB

cmp byte ptr [rcx + r10], 0xFF

jne LOCAL_LABEL(SetCardTableByte_ByRefWriteBarrier)

jne LOCAL_LABEL(SetCardTableByte_ByRefWriteBarrierBatch)

// Check if we have more in the batch and run again

dec r8d

jne LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)

REPRET

LOCAL_LABEL(SetCardTableByte_ByRefWriteBarrier):

LOCAL_LABEL(SetCardTableByte_ByRefWriteBarrierBatch):

mov byte ptr [rcx + r10], 0xFF

LOCAL_LABEL(CheckCardBundle_ByRefWriteBarrier):

LOCAL_LABEL(CheckCardBundle_ByRefWriteBarrierBatch):

#ifdef FEATURE_MANUALLY_MANAGED_CARD_BUNDLES

// Shift rcx by 0x0A more to get the card bundle byte (we shifted by 0x0B already)

shr rcx, 0x0A

PREPARE_EXTERNAL_VAR g_card_bundle_table, rax

add rcx, [rax]

// Check if this bundle byte is dirty

cmp byte ptr [rcx], 0xFF

jne LOCAL_LABEL(UpdateCardBundle_ByRefWriteBarrier)

jne LOCAL_LABEL(UpdateCardBundle_ByRefWriteBarrierBatch)

// Check if we have more in the batch and run again

dec r8d

jne LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)

REPRET

LOCAL_LABEL(UpdateCardBundle_ByRefWriteBarrier):

LOCAL_LABEL(UpdateCardBundle_ByRefWriteBarrierBatch):

mov byte ptr [rcx], 0xFF

#endif

// Check if we have more in the batch and run again

dec r8d

jne LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)

ret

.balign 16

LOCAL_LABEL(NotInHeap_ByRefWriteBarrier):

LOCAL_LABEL(NotInHeap_ByRefWriteBarrierBatch):

// If WRITE_BARRIER_CHECK then we won't have already done the mov and should do it here

// If !WRITE_BARRIER_CHECK we want _NotInHeap and _Leave to be the same and have both

// 16 byte aligned.

#ifdef WRITE_BARRIER_CHECK

// rcx is [rsi]

mov [rdi], rcx

#endif

LOCAL_LABEL(Exit_ByRefWriteBarrier):

// At least one write is already done, increment the pointers

add rdi, 0x8

add rsi, 0x8

dec r8d

je LOCAL_LABEL(NotInHeapExit)

// Now we can do the rest of the writes without checking the heap

LOCAL_LABEL(NextByrefUnchecked):

mov rcx, [rsi]

mov [rdi], rcx

add rdi, 0x8

add rsi, 0x8

dec r8d

jne LOCAL_LABEL(NextByrefUnchecked)

LOCAL_LABEL(NotInHeapExit):

ret

LOCAL_LABEL(Exit_ByRefWriteBarrierBatch):

// Increment the pointers before leaving

add rdi, 0x8

add rsi, 0x8

// Check if we have more in the batch and run again

dec r8d

jne LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)

ret

LEAF_END_MARKED JIT_ByRefWriteBarrier, _TEXT

LEAF_END_MARKED JIT_ByRefWriteBarrierBatch, _TEXT

Saved diffs

Original text

Open file

LEAF_ENTRY JIT_ByRefWriteBarrier, _TEXT
        mov     rcx, [rsi]

// If !WRITE_BARRIER_CHECK do the write first, otherwise we might have to do some ShadowGC stuff
#ifndef WRITE_BARRIER_CHECK
        // rcx is [rsi]
        mov     [rdi], rcx
#endif

// When WRITE_BARRIER_CHECK is defined _NotInHeap will write the reference
        // but if it isn't then it will just return.
        //
        // See if this is in GCHeap
        PREPARE_EXTERNAL_VAR g_lowest_address, rax
        cmp     rdi, [rax]
        jb      LOCAL_LABEL(NotInHeap_ByRefWriteBarrier)
        PREPARE_EXTERNAL_VAR g_highest_address, rax
        cmp     rdi, [rax]
        jnb     LOCAL_LABEL(NotInHeap_ByRefWriteBarrier)

#ifdef WRITE_BARRIER_CHECK
        // **ALSO update the shadow GC heap if that is enabled**
        // Do not perform the work if g_GCShadow is 0
        PREPARE_EXTERNAL_VAR g_GCShadow, rax
        cmp     qword ptr [rax], 0
        je      LOCAL_LABEL(NoShadow_ByRefWriteBarrier)

// If we end up outside of the heap don't corrupt random memory
        mov     r10, rdi
        PREPARE_EXTERNAL_VAR g_lowest_address, rax
        sub     r10, [rax]
        jb      LOCAL_LABEL(NoShadow_ByRefWriteBarrier)

// Check that our adjusted destination is somewhere in the shadow gc
        PREPARE_EXTERNAL_VAR g_GCShadow, rax
        add     r10, [rax]
        PREPARE_EXTERNAL_VAR g_GCShadowEnd, rax
        cmp     r10, [rax]
        jnb     LOCAL_LABEL(NoShadow_ByRefWriteBarrier)

// Write ref into real GC
        mov     [rdi], rcx
        // Write ref into shadow GC
        mov     [r10], rcx

// Ensure that the write to the shadow heap occurs before the read from
        // the GC heap so that race conditions are caught by INVALIDGCVALUE
        mfence

// Check that GC/ShadowGC values match
        mov     r11, [rdi]
        mov     rax, [r10]
        cmp     rax, r11
        je      LOCAL_LABEL(DoneShadow_ByRefWriteBarrier)
        movabs  r11, INVALIDGCVALUE
        mov     [r10], r11

jmp     LOCAL_LABEL(DoneShadow_ByRefWriteBarrier)

// If we don't have a shadow GC we won't have done the write yet
    LOCAL_LABEL(NoShadow_ByRefWriteBarrier):
        mov     [rdi], rcx

// If we had a shadow GC then we already wrote to the real GC at the same time
    // as the shadow GC so we want to jump over the real write immediately above.
    // Additionally we know for sure that we are inside the heap and therefore don't
    // need to replicate the above checks.
    LOCAL_LABEL(DoneShadow_ByRefWriteBarrier):
#endif

#ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
        // Update the write watch table if necessary
        PREPARE_EXTERNAL_VAR g_sw_ww_enabled_for_gc_heap, rax
        cmp     byte ptr [rax], 0x0
        je      LOCAL_LABEL(CheckCardTable_ByRefWriteBarrier)
        mov     rax, rdi
        shr     rax, 0xC // SoftwareWriteWatch::AddressToTableByteIndexShift
        PREPARE_EXTERNAL_VAR g_sw_ww_table, r10
        add     rax, qword ptr [r10]
        cmp     byte ptr [rax], 0x0
        jne     LOCAL_LABEL(CheckCardTable_ByRefWriteBarrier)
        mov     byte ptr [rax], 0xFF
#endif

LOCAL_LABEL(CheckCardTable_ByRefWriteBarrier):
        // See if we can just quick out
        PREPARE_EXTERNAL_VAR g_ephemeral_low, rax
        cmp     rcx, [rax]
        jb      LOCAL_LABEL(Exit_ByRefWriteBarrier)
        PREPARE_EXTERNAL_VAR g_ephemeral_high, rax
        cmp     rcx, [rax]
        jnb     LOCAL_LABEL(Exit_ByRefWriteBarrier)

mov     rax, rcx

PREPARE_EXTERNAL_VAR g_region_shr, rcx
        mov     cl, [rcx]
        test    cl, cl
        je      LOCAL_LABEL(SkipCheck_ByRefWriteBarrier)

// check if the source is in gen 2 - then it's not an ephemeral pointer
        shr     rax, cl
        PREPARE_EXTERNAL_VAR g_region_to_generation_table, r10
        mov     r10, [r10]
        cmp     byte ptr [rax + r10], 0x82
        je      LOCAL_LABEL(Exit_ByRefWriteBarrier)

// check if the destination happens to be in gen 0
        mov     rax, rdi
        shr     rax, cl
        cmp     byte ptr [rax + r10], 0
        je      LOCAL_LABEL(Exit_ByRefWriteBarrier)
    LOCAL_LABEL(SkipCheck_ByRefWriteBarrier):

PREPARE_EXTERNAL_VAR g_card_table, r10
        mov     r10, [r10]

PREPARE_EXTERNAL_VAR g_region_use_bitwise_write_barrier, rax
        cmp     byte ptr [rax], 0
        je      LOCAL_LABEL(CheckCardTableByte_ByRefWriteBarrier)

// compute card table bit
        mov     ecx, edi
        mov     al, 1
        shr     ecx, 8
        and     cl, 7
        shl     al, cl

// move current rdi value into rcx and then increment the pointers
        mov     rcx, rdi
        add     rsi, 0x8
        add     rdi, 0x8

LOCAL_LABEL(SetCardTableBit_ByRefWriteBarrier):
        lock or byte ptr [rcx + r10], al

jmp     LOCAL_LABEL(CheckCardBundle_ByRefWriteBarrier)

LOCAL_LABEL(CheckCardTableByte_ByRefWriteBarrier):
        // move current rdi value into rcx and then increment the pointers
        mov     rcx, rdi
        add     rsi, 0x8
        add     rdi, 0x8

shr     rcx, 0xB
        cmp     byte ptr [rcx + r10], 0xFF
        jne     LOCAL_LABEL(SetCardTableByte_ByRefWriteBarrier)
        REPRET
    LOCAL_LABEL(SetCardTableByte_ByRefWriteBarrier):
        mov     byte ptr [rcx + r10], 0xFF

LOCAL_LABEL(CheckCardBundle_ByRefWriteBarrier):

#ifdef FEATURE_MANUALLY_MANAGED_CARD_BUNDLES
        // Shift rcx by 0x0A more to get the card bundle byte (we shifted by 0x0B already)
        shr     rcx, 0x0A

PREPARE_EXTERNAL_VAR g_card_bundle_table, rax
        add     rcx, [rax]

// Check if this bundle byte is dirty
        cmp     byte ptr [rcx], 0xFF

jne     LOCAL_LABEL(UpdateCardBundle_ByRefWriteBarrier)
        REPRET

LOCAL_LABEL(UpdateCardBundle_ByRefWriteBarrier):
        mov     byte ptr [rcx], 0xFF
#endif

ret

.balign 16
    LOCAL_LABEL(NotInHeap_ByRefWriteBarrier):
// If WRITE_BARRIER_CHECK then we won't have already done the mov and should do it here
// If !WRITE_BARRIER_CHECK we want _NotInHeap and _Leave to be the same and have both
// 16 byte aligned.
#ifdef WRITE_BARRIER_CHECK
        // rcx is [rsi]
        mov     [rdi], rcx
#endif
    LOCAL_LABEL(Exit_ByRefWriteBarrier):
        // Increment the pointers before leaving
        add     rdi, 0x8
        add     rsi, 0x8
        ret
LEAF_END_MARKED JIT_ByRefWriteBarrier, _TEXT

Changed text

Open file

LEAF_ENTRY JIT_ByRefWriteBarrierBatch, _TEXT
    LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch):
        mov     rcx, [rsi]

// If !WRITE_BARRIER_CHECK do the write first, otherwise we might have to do some ShadowGC stuff
#ifndef WRITE_BARRIER_CHECK
        // rcx is [rsi]
        mov     [rdi], rcx
#endif

// When WRITE_BARRIER_CHECK is defined _NotInHeap will write the reference
        // but if it isn't then it will just return.
        //
        // See if this is in GCHeap
        PREPARE_EXTERNAL_VAR g_lowest_address, rax
        cmp     rdi, [rax]
        jb      LOCAL_LABEL(NotInHeap_ByRefWriteBarrierBatch)
        PREPARE_EXTERNAL_VAR g_highest_address, rax
        cmp     rdi, [rax]
        jnb     LOCAL_LABEL(NotInHeap_ByRefWriteBarrierBatch)

// Write ref into real GC
        mov     [rdi], rcx
        // Write ref into shadow GC
        mov     [r10], rcx

// Ensure that the write to the shadow heap occurs before the read from
        // the GC heap so that race conditions are caught by INVALIDGCVALUE
        mfence

// Check that GC/ShadowGC values match
        mov     r11, [rdi]
        mov     rax, [r10]
        cmp     rax, r11
        je      LOCAL_LABEL(DoneShadow_ByRefWriteBarrierBatch)
        movabs  r11, INVALIDGCVALUE
        mov     [r10], r11

jmp     LOCAL_LABEL(DoneShadow_ByRefWriteBarrierBatch)

// If we don't have a shadow GC we won't have done the write yet
    LOCAL_LABEL(NoShadow_ByRefWriteBarrierBatch):
        mov     [rdi], rcx

#ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
        // Update the write watch table if necessary
        PREPARE_EXTERNAL_VAR g_sw_ww_enabled_for_gc_heap, rax
        cmp     byte ptr [rax], 0x0
        je      LOCAL_LABEL(CheckCardTable_ByRefWriteBarrierBatch)
        mov     rax, rdi
        shr     rax, 0xC // SoftwareWriteWatch::AddressToTableByteIndexShift
        PREPARE_EXTERNAL_VAR g_sw_ww_table, r10
        add     rax, qword ptr [r10]
        cmp     byte ptr [rax], 0x0
        jne     LOCAL_LABEL(CheckCardTable_ByRefWriteBarrierBatch)
        mov     byte ptr [rax], 0xFF
#endif

LOCAL_LABEL(CheckCardTable_ByRefWriteBarrierBatch):
        // See if we can just quick out
        PREPARE_EXTERNAL_VAR g_ephemeral_low, rax
        cmp     rcx, [rax]
        jb      LOCAL_LABEL(Exit_ByRefWriteBarrierBatch)
        PREPARE_EXTERNAL_VAR g_ephemeral_high, rax
        cmp     rcx, [rax]
        jnb     LOCAL_LABEL(Exit_ByRefWriteBarrierBatch)

mov     rax, rcx

PREPARE_EXTERNAL_VAR g_region_shr, rcx
        mov     cl, [rcx]
        test    cl, cl
        je      LOCAL_LABEL(SkipCheck_ByRefWriteBarrierBatch)

// check if the destination happens to be in gen 0
        mov     rax, rdi
        shr     rax, cl
        cmp     byte ptr [rax + r10], 0
        je      LOCAL_LABEL(Exit_ByRefWriteBarrierBatch)
    LOCAL_LABEL(SkipCheck_ByRefWriteBarrierBatch):

PREPARE_EXTERNAL_VAR g_card_table, r10
        mov     r10, [r10]

PREPARE_EXTERNAL_VAR g_region_use_bitwise_write_barrier, rax
        cmp     byte ptr [rax], 0
        je      LOCAL_LABEL(CheckCardTableByte_ByRefWriteBarrierBatch)

// compute card table bit
        mov     ecx, edi
        mov     al, 1
        shr     ecx, 8
        and     cl, 7
        shl     al, cl

// move current rdi value into rcx and then increment the pointers
        mov     rcx, rdi
        add     rsi, 0x8
        add     rdi, 0x8

// Check if we need to update the card table
        // Calc pCardByte
        shr     rcx, 0xB
        // Check if this card table bit is already set
        test    byte ptr [rcx + r10], al
        je      LOCAL_LABEL(SetCardTableBit_ByRefWriteBarrierBatch)
        // Check if we have more in the batch and run again
        dec     r8d
        jne     LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)
        REPRET

LOCAL_LABEL(SetCardTableBit_ByRefWriteBarrierBatch):
        lock or byte ptr [rcx + r10], al

jmp     LOCAL_LABEL(CheckCardBundle_ByRefWriteBarrierBatch)

LOCAL_LABEL(CheckCardTableByte_ByRefWriteBarrierBatch):
        // move current rdi value into rcx and then increment the pointers
        mov     rcx, rdi
        add     rsi, 0x8
        add     rdi, 0x8

shr     rcx, 0xB
        cmp     byte ptr [rcx + r10], 0xFF
        jne     LOCAL_LABEL(SetCardTableByte_ByRefWriteBarrierBatch)
        // Check if we have more in the batch and run again
        dec     r8d
        jne     LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)
        REPRET
    LOCAL_LABEL(SetCardTableByte_ByRefWriteBarrierBatch):
        mov     byte ptr [rcx + r10], 0xFF

LOCAL_LABEL(CheckCardBundle_ByRefWriteBarrierBatch):

#ifdef FEATURE_MANUALLY_MANAGED_CARD_BUNDLES
        // Shift rcx by 0x0A more to get the card bundle byte (we shifted by 0x0B already)
        shr     rcx, 0x0A

PREPARE_EXTERNAL_VAR g_card_bundle_table, rax
        add     rcx, [rax]

// Check if this bundle byte is dirty
        cmp     byte ptr [rcx], 0xFF

jne     LOCAL_LABEL(UpdateCardBundle_ByRefWriteBarrierBatch)
        // Check if we have more in the batch and run again
        dec     r8d
        jne     LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)
        REPRET

LOCAL_LABEL(UpdateCardBundle_ByRefWriteBarrierBatch):
        mov     byte ptr [rcx], 0xFF
#endif
        // Check if we have more in the batch and run again
        dec     r8d
        jne     LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)
        ret

.balign 16
    LOCAL_LABEL(NotInHeap_ByRefWriteBarrierBatch):
// If WRITE_BARRIER_CHECK then we won't have already done the mov and should do it here
// If !WRITE_BARRIER_CHECK we want _NotInHeap and _Leave to be the same and have both
// 16 byte aligned.
#ifdef WRITE_BARRIER_CHECK
        // rcx is [rsi]
        mov     [rdi], rcx
#endif

// At least one write is already done, increment the pointers
        add     rdi, 0x8
        add     rsi, 0x8
        dec     r8d
        je      LOCAL_LABEL(NotInHeapExit)
    // Now we can do the rest of the writes without checking the heap
    LOCAL_LABEL(NextByrefUnchecked):
        mov     rcx, [rsi]
        mov     [rdi], rcx
        add     rdi, 0x8
        add     rsi, 0x8
        dec     r8d
        jne     LOCAL_LABEL(NextByrefUnchecked)
    LOCAL_LABEL(NotInHeapExit):
        ret

LOCAL_LABEL(Exit_ByRefWriteBarrierBatch):
        // Increment the pointers before leaving
        add     rdi, 0x8
        add     rsi, 0x8
        // Check if we have more in the batch and run again
        dec     r8d
        jne     LOCAL_LABEL(NextByref_ByRefWriteBarrierBatch)
        ret
LEAF_END_MARKED JIT_ByRefWriteBarrierBatch, _TEXT