DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (5b81998bb7ab)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
; -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
; This Source Code Form is subject to the terms of the Mozilla Public
; License, v. 2.0. If a copy of the MPL was not distributed with this
; file, You can obtain one at http://mozilla.org/MPL/2.0/.


extern js_InternalThrow:PROC
extern PushActiveVMFrame:PROC
extern PopActiveVMFrame:PROC
extern js_InternalInterpret:PROC

.CODE

; JSBool JaegerTrampoline(JSContext *cx, StackFrame *fp, void *code,
;                         Value *stackLimit, void *safePoint);
JaegerTrampoline PROC FRAME
    push    rbp
    .PUSHREG rbp
    mov     rbp, rsp
    .SETFRAME rbp, 0
    push    r12
    .PUSHREG r12
    push    r13
    .PUSHREG r13
    push    r14
    .PUSHREG r14
    push    r15
    .PUSHREG r15
    push    rdi
    .PUSHREG rdi
    push    rsi
    .PUSHREG rsi
    push    rbx
    .PUSHREG rbx
    sub     rsp, 16*10+8
    .ALLOCSTACK 168
    ; .SAVEXMM128 only supports 16 byte alignment offset
    movdqa  xmmword ptr [rsp], xmm6
    .SAVEXMM128 xmm6, 0
    movdqa  xmmword ptr [rsp+16], xmm7
    .SAVEXMM128 xmm7, 16
    movdqa  xmmword ptr [rsp+16*2], xmm8
    .SAVEXMM128 xmm8, 32
    movdqa  xmmword ptr [rsp+16*3], xmm9
    .SAVEXMM128 xmm9, 48
    movdqa  xmmword ptr [rsp+16*4], xmm10
    .SAVEXMM128 xmm10, 64
    movdqa  xmmword ptr [rsp+16*5], xmm11
    .SAVEXMM128 xmm11, 80
    movdqa  xmmword ptr [rsp+16*6], xmm12
    .SAVEXMM128 xmm12, 96
    movdqa  xmmword ptr [rsp+16*7], xmm13
    .SAVEXMM128 xmm13, 112
    movdqa  xmmword ptr [rsp+16*8], xmm14
    .SAVEXMM128 xmm14, 128
    movdqa  xmmword ptr [rsp+16*9], xmm15
    .SAVEXMM128 xmm15, 144
    ; stack aligment  for Win64 ABI
    sub     rsp, 8
    .ALLOCSTACK 8
    .ENDPROLOG

    ; Load mask registers
    mov     r13, 0ffff800000000000h
    mov     r14, 7fffffffffffh

    ; Build the JIT frame.
    ; rcx = cx
    ; rdx = fp
    ; r9 = inlineCallCount
    ; fp must go into rbx
    push    0       ; stubRejoin
    push    rdx     ; entryncode
    push    rdx     ; entryFp
    push    r9      ; inlineCallCount
    push    rcx     ; cx
    push    rdx     ; fp
    mov     rbx, rdx

    ; Space for the rest of the VMFrame.
    sub     rsp, 28h

    ; This is actually part of the VMFrame.
    mov     r10, [rbp+8*5+8]
    push    r10

    ; Set cx->regs and set the active frame. Save r8 and align frame in one
    push    r8
    mov     rcx, rsp
    sub     rsp, 20h
    call    PushActiveVMFrame
    add     rsp, 20h

    ; Jump into the JIT code.
    jmp     qword ptr [rsp]
JaegerTrampoline ENDP

; void JaegerTrampolineReturn();
JaegerTrampolineReturn PROC FRAME
    .ENDPROLOG
    or      rsi, rdi
    mov     qword ptr [rbx+30h], rsi
    sub     rsp, 20h
    lea     rcx, [rsp+20h]
    call    PopActiveVMFrame

    add     rsp, 68h+20h+8+16*10+8
    movdqa  xmm6, xmmword ptr [rsp-16*10-8]
    movdqa  xmm7, xmmword ptr [rsp-16*9-8]
    movdqa  xmm8, xmmword ptr [rsp-16*8-8]
    movdqa  xmm9, xmmword ptr [rsp-16*7-8]
    movdqa  xmm10, xmmword ptr [rsp-16*6-8]
    movdqa  xmm11, xmmword ptr [rsp-16*5-8]
    movdqa  xmm12, xmmword ptr [rsp-16*4-8]
    movdqa  xmm13, xmmword ptr [rsp-16*3-8]
    movdqa  xmm14, xmmword ptr [rsp-16*2-8]
    movdqa  xmm15, xmmword ptr [rsp-16*1-8]
    pop     rbx
    pop     rsi
    pop     rdi
    pop     r15
    pop     r14
    pop     r13
    pop     r12
    pop     rbp
    mov     rax, 1
    ret
JaegerTrampolineReturn ENDP


; void JaegerThrowpoline()
JaegerThrowpoline PROC FRAME
    .ENDPROLOG
    ; For Windows x64 stub calls, we pad the stack by 32 before
    ; calling, so we must account for that here. See doStubCall.
    lea     rcx, [rsp+20h]
    call    js_InternalThrow
    test    rax, rax
    je      throwpoline_exit
    add     rsp, 20h
    jmp     rax

throwpoline_exit:
    lea     rcx, [rsp+20h]
    call    PopActiveVMFrame
    add     rsp, 68h+20h+8+16*10+8
    movdqa  xmm6, xmmword ptr [rsp-16*10-8]
    movdqa  xmm7, xmmword ptr [rsp-16*9-8]
    movdqa  xmm8, xmmword ptr [rsp-16*8-8]
    movdqa  xmm9, xmmword ptr [rsp-16*7-8]
    movdqa  xmm10, xmmword ptr [rsp-16*6-8]
    movdqa  xmm11, xmmword ptr [rsp-16*5-8]
    movdqa  xmm12, xmmword ptr [rsp-16*4-8]
    movdqa  xmm13, xmmword ptr [rsp-16*3-8]
    movdqa  xmm14, xmmword ptr [rsp-16*2-8]
    movdqa  xmm15, xmmword ptr [rsp-16*1-8]
    pop     rbx
    pop     rsi
    pop     rdi
    pop     r15
    pop     r14
    pop     r13
    pop     r12
    pop     rbp
    xor     rax, rax
    ret
JaegerThrowpoline ENDP

JaegerInterpoline PROC FRAME
    .ENDPROLOG
    mov     rcx, rdi
    mov     rdx, rsi
    lea     r9, [rsp+20h]
    mov     r8, rax
    call    js_InternalInterpret
    mov     rbx, qword ptr [rsp+38h+20h] ; Load Frame
    mov     rsi, qword ptr [rbx+30h]     ; Load rval payload
    and     rsi, r14                     ; Mask rval payload
    mov     rdi, qword ptr [rbx+30h]     ; Load rval type
    and     rdi, r13                     ; Mask rval type
    mov     rcx, qword ptr [rsp+18h+20h] ; Load scratch -> argc
    test    rax, rax
    je      interpoline_exit
    add     rsp, 20h
    jmp     rax

interpoline_exit:
    lea     rcx, [rsp+20h]
    call    PopActiveVMFrame
    add     rsp, 68h+20h+8+16*10+8
    movdqa  xmm6, xmmword ptr [rsp-16*10-8]
    movdqa  xmm7, xmmword ptr [rsp-16*9-8]
    movdqa  xmm8, xmmword ptr [rsp-16*8-8]
    movdqa  xmm9, xmmword ptr [rsp-16*7-8]
    movdqa  xmm10, xmmword ptr [rsp-16*6-8]
    movdqa  xmm11, xmmword ptr [rsp-16*5-8]
    movdqa  xmm12, xmmword ptr [rsp-16*4-8]
    movdqa  xmm13, xmmword ptr [rsp-16*3-8]
    movdqa  xmm14, xmmword ptr [rsp-16*2-8]
    movdqa  xmm15, xmmword ptr [rsp-16*1-8]
    pop     rbx
    pop     rsi
    pop     rdi
    pop     r15
    pop     r14
    pop     r13
    pop     r12
    pop     rbp
    xor     rax, rax
    ret
JaegerInterpoline ENDP

JaegerInterpolineScripted PROC FRAME
    .ENDPROLOG
    mov     rbx, qword ptr [rbx+20h] ; Load prev
    mov     qword ptr [rsp+38h], rbx ; fp -> regs.fp
    sub     rsp, 20h
    jmp     JaegerInterpoline
JaegerInterpolineScripted ENDP

JaegerInterpolinePatched PROC FRAME
    sub     rsp, 20h
    .ALLOCSTACK 32
    .ENDPROLOG
    jmp     JaegerInterpoline
JaegerInterpolinePatched ENDP


END