src/vm/amd64/jithelpers_fast.S

   1 //
   2 // Copyright (c) Microsoft. All rights reserved.
   3 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
   4 //
   5
   6 .intel_syntax noprefix
   7 #include "unixasmmacros.inc"
   8
   9 // Mark start of the code region that we patch at runtime
  10 LEAF_ENTRY JIT_PatchedCodeStart, _TEXT
  11         ret
  12 LEAF_END JIT_PatchedCodeStart, _TEXT
  13
  14 // This is used by the mechanism to hold either the JIT_WriteBarrier_PreGrow
  15 // or JIT_WriteBarrier_PostGrow code (depending on the state of the GC). It _WILL_
  16 // change at runtime as the GC changes. Initially it should simply be a copy of the
  17 // larger of the two functions (JIT_WriteBarrier_PostGrow) to ensure we have created
  18 // enough space to copy that code in.
  19 .balign 16
  20 LEAF_ENTRY JIT_WriteBarrier, _TEXT
  21 #ifdef _DEBUG
  22         // In debug builds, this just contains jump to the debug version of the write barrier by default
  23         jmp C_FUNC(JIT_WriteBarrier_Debug)
  24 #endif
  25
  26         // Do the move into the GC .  It is correct to take an AV here, the EH code
  27         // figures out that this came from a WriteBarrier and correctly maps it back
  28         // to the managed method which called the WriteBarrier (see setup in
  29         // InitializeExceptionHandling, vm\exceptionhandling.cpp).
  30         mov     [rdi], rsi
  31
  32         NOP_3_BYTE // padding for alignment of constant
  33
  34         // Can't compare a 64 bit immediate, so we have to move them into a
  35         // register.  Values of these immediates will be patched at runtime.
  36         // By using two registers we can pipeline better.  Should we decide to use
  37         // a special non-volatile calling convention, this should be changed to
  38         // just one.
  39
  40         movabs  rax, 0xF0F0F0F0F0F0F0F0
  41
  42         // Check the lower and upper ephemeral region bounds
  43         cmp     rsi, rax
  44         // jb      Exit
  45         .byte 0x72, 0x36
  46
  47         nop // padding for alignment of constant
  48
  49         movabs  r8, 0xF0F0F0F0F0F0F0F0
  50
  51         cmp     rsi, r8
  52         // jae     Exit
  53         .byte 0x73, 0x26
  54
  55         nop // padding for alignment of constant
  56
  57         movabs  rax, 0xF0F0F0F0F0F0F0F0
  58
  59         // Touch the card table entry, if not already dirty.
  60         shr     rdi, 0Bh
  61         cmp     byte ptr [rdi + rax], 0FFh
  62         // jne     UpdateCardTable
  63         .byte 0x75, 0x02
  64         REPRET
  65
  66     UpdateCardTable:
  67         mov     byte ptr [rdi + rax], 0FFh
  68         ret
  69
  70     .balign 16
  71     Exit:
  72         REPRET
  73     // make sure this guy is bigger than any of the other guys
  74     .balign 16
  75         nop
  76 LEAF_END_MARKED JIT_WriteBarrier, _TEXT
  77
  78 // Mark start of the code region that we patch at runtime
  79 LEAF_ENTRY JIT_PatchedCodeLast, _TEXT
  80         ret
  81 LEAF_END JIT_PatchedCodeLast, _TEXT
  82
  83 // There is an even more optimized version of these helpers possible which takes
  84 // advantage of knowledge of which way the ephemeral heap is growing to only do 1/2
  85 // that check (this is more significant in the JIT_WriteBarrier case).
  86 //
  87 // Additionally we can look into providing helpers which will take the src/dest from
  88 // specific registers (like x86) which _could_ (??) make for easier register allocation
  89 // for the JIT64, however it might lead to having to have some nasty code that treats
  90 // these guys really special like... :(.
  91 //
  92 // Version that does the move, checks whether or not it's in the GC and whether or not
  93 // it needs to have it's card updated
  94 //
  95 // void JIT_CheckedWriteBarrier(Object** dst, Object* src)
  96 LEAF_ENTRY JIT_CheckedWriteBarrier, _TEXT
  97
  98         // When WRITE_BARRIER_CHECK is defined _NotInHeap will write the reference
  99         // but if it isn't then it will just return.
 100         //
 101         // See if this is in GCHeap
 102         PREPARE_EXTERNAL_VAR g_lowest_address, rax
 103         cmp     rdi, [rax]
 104         // jb      NotInHeap
 105         .byte 0x72, 0x0e
 106         PREPARE_EXTERNAL_VAR g_highest_address, rax
 107         cmp     rdi, [rax]
 108         // jnb     NotInHeap
 109         .byte 0x73, 0x02
 110
 111         // call C_FUNC(JIT_WriteBarrier)
 112         .byte 0xeb, 0x84
 113
 114     NotInHeap:
 115         // See comment above about possible AV
 116         mov     [rdi], rsi
 117         ret
 118 LEAF_END_MARKED JIT_CheckedWriteBarrier, _TEXT
 119
 120 // JIT_ByRefWriteBarrier has weird symantics, see usage in StubLinkerX86.cpp
 121 //
 122 // Entry:
 123 //   RDI - address of ref-field (assigned to)
 124 //   RSI - address of the data  (source)
 125 //   RCX can be trashed
 126 // Exit:
 127 //   RDI, RSI are incremented by SIZEOF(LPVOID)
 128 LEAF_ENTRY JIT_ByRefWriteBarrier, _TEXT
 129         push    rax
 130         mov     rcx, [rsi]
 131
 132 // If !WRITE_BARRIER_CHECK do the write first, otherwise we might have to do some ShadowGC stuff
 133 #ifndef WRITE_BARRIER_CHECK
 134         // rcx is [rsi]
 135         mov     [rdi], rcx
 136 #endif
 137
 138         // When WRITE_BARRIER_CHECK is defined _NotInHeap will write the reference
 139         // but if it isn't then it will just return.
 140         //
 141         // See if this is in GCHeap
 142         PREPARE_EXTERNAL_VAR g_lowest_address, rax
 143         cmp     rdi, [rax]
 144         jb      NotInHeap_ByRefWriteBarrier
 145         PREPARE_EXTERNAL_VAR g_highest_address, rax
 146         cmp     rdi, [rax]
 147         jnb     NotInHeap_ByRefWriteBarrier
 148
 149 #ifdef WRITE_BARRIER_CHECK
 150         // we can only trash rcx in this function so in _DEBUG we need to save
 151         // some scratch registers.
 152         push    r10
 153         push    r11
 154
 155         // **ALSO update the shadow GC heap if that is enabled**
 156         // Do not perform the work if g_GCShadow is 0
 157         PREPARE_EXTERNAL_VAR g_GCShadow, rax
 158         cmp     qword ptr [rax], 0
 159         je      NoShadow_ByRefWriteBarrier
 160
 161         // If we end up outside of the heap don't corrupt random memory
 162         mov     r10, rdi
 163         PREPARE_EXTERNAL_VAR g_lowest_address, rax
 164         sub     r10, [rax]
 165         jb      NoShadow_ByRefWriteBarrier
 166
 167         // Check that our adjusted destination is somewhere in the shadow gc
 168         PREPARE_EXTERNAL_VAR g_GCShadow, rax
 169         add     r10, [rax]
 170         PREPARE_EXTERNAL_VAR g_GCShadowEnd, rax
 171         cmp     r10, [rax]
 172         ja      NoShadow_ByRefWriteBarrier
 173
 174         // Write ref into real GC
 175         mov     [rdi], rcx
 176         // Write ref into shadow GC
 177         mov     [r10], rcx
 178
 179         // Ensure that the write to the shadow heap occurs before the read from
 180         // the GC heap so that race conditions are caught by INVALIDGCVALUE
 181         mfence
 182
 183         // Check that GC/ShadowGC values match
 184         mov     r11, [rdi]
 185         mov     rax, [r10]
 186         cmp     rax, r11
 187         je      DoneShadow_ByRefWriteBarrier
 188         mov     r11, INVALIDGCVALUE
 189         mov     [r10], r11
 190
 191         jmp     DoneShadow_ByRefWriteBarrier
 192
 193     // If we don't have a shadow GC we won't have done the write yet
 194     NoShadow_ByRefWriteBarrier:
 195         mov     [rdi], rcx
 196
 197     // If we had a shadow GC then we already wrote to the real GC at the same time
 198     // as the shadow GC so we want to jump over the real write immediately above.
 199     // Additionally we know for sure that we are inside the heap and therefore don't
 200     // need to replicate the above checks.
 201     DoneShadow_ByRefWriteBarrier:
 202         pop     r11
 203         pop     r10
 204 #endif
 205
 206         // See if we can just quick out
 207         PREPARE_EXTERNAL_VAR g_ephemeral_low, rax
 208         cmp     rcx, [rax]
 209         jb      Exit_ByRefWriteBarrier
 210         PREPARE_EXTERNAL_VAR g_ephemeral_high, rax
 211         cmp     rcx, [rax]
 212         jnb     Exit_ByRefWriteBarrier
 213
 214         // move current rdi value into rcx and then increment the pointers
 215         mov     rcx, rdi
 216         add     rsi, 8h
 217         add     rdi, 8h
 218
 219         // Check if we need to update the card table
 220         // Calc pCardByte
 221         shr     rcx, 0Bh
 222         PREPARE_EXTERNAL_VAR g_card_table, rax
 223         add     rcx, [rax]
 224
 225         pop     rax
 226
 227         // Check if this card is dirty
 228         cmp     byte ptr [rcx], 0FFh
 229         jne     UpdateCardTable_ByRefWriteBarrier
 230         REPRET
 231
 232     UpdateCardTable_ByRefWriteBarrier:
 233         mov     byte ptr [rcx], 0FFh
 234         ret
 235
 236     .balign 16
 237     NotInHeap_ByRefWriteBarrier:
 238 // If WRITE_BARRIER_CHECK then we won't have already done the mov and should do it here
 239 // If !WRITE_BARRIER_CHECK we want _NotInHeap and _Leave to be the same and have both
 240 // 16 byte aligned.
 241 #ifdef WRITE_BARRIER_CHECK
 242         // rcx is [rsi]
 243         mov     [rdi], rcx
 244 #endif
 245     Exit_ByRefWriteBarrier:
 246         // Increment the pointers before leaving
 247         add     rdi, 8h
 248         add     rsi, 8h
 249         pop     rax
 250         ret
 251 LEAF_END JIT_ByRefWriteBarrier, _TEXT