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
# -*- 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
.extern PushActiveVMFrame
.extern PopActiveVMFrame
.extern js_InternalInterpret

.text
.intel_syntax noprefix

# JSBool JaegerTrampoline(JSContext *cx, StackFrame *fp, void *code,
#                         Value *stackLimit, void *safePoint)#
.globl JaegerTrampoline
.def JaegerTrampoline
   .scl 3
   .type 46
.endef
JaegerTrampoline:
    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
    # .ENDPROLOG

    # Load mask registers
    mov     r13, 0xffff800000000000
    mov     r14, 0x7fffffffffff

    # 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, 0x28

    # 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, 0x20
    call    PushActiveVMFrame
    add     rsp, 0x20

    # Jump into the JIT code.
    jmp     qword ptr [rsp]

# void JaegerTrampolineReturn()#
.globl JaegerTrampolineReturn
.def JaegerTrampolineReturn
   .scl 3
   .type 46
.endef
JaegerTrampolineReturn:
    # .ENDPROLOG
    or      rsi, rdi
    mov     qword ptr [rbx + 0x30], rsi
    sub     rsp, 0x20
    lea     rcx, [rsp+0x20]
    call    PopActiveVMFrame

    add     rsp, 0x68+0x20
    pop     rbx
    pop     rsi
    pop     rdi
    pop     r15
    pop     r14
    pop     r13
    pop     r12
    pop     rbp
    mov     rax, 1
    ret


# void JaegerThrowpoline()
.globl JaegerThrowpoline
.def JaegerTrampoline
   .scl 3
   .type 46
.endef
JaegerThrowpoline:
    # .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+0x20]
    call    js_InternalThrow
    test    rax, rax
    je      throwpoline_exit
    add     rsp, 0x20
    jmp     rax

throwpoline_exit:
    lea     rcx, [rsp+0x20]
    call    PopActiveVMFrame
    add     rsp, 0x68+0x20
    pop     rbx
    pop     rsi
    pop     rdi
    pop     r15
    pop     r14
    pop     r13
    pop     r12
    pop     rbp
    xor     rax, rax
    ret


.globl JaegerInterpoline
.def JaegerInterpoline
   .scl 3
   .type 46
.endef
JaegerInterpoline:
    #.ENDPROLOG
    mov     rcx, rdi
    mov     rdx, rsi
    lea     r9, [rsp+0x20]
    mov     r8, rax
    call    js_InternalInterpret
    mov     rbx, qword ptr [rsp+0x38+0x20] # Load Frame
    mov     rsi, qword ptr [rbx+0x30]      # Load rval payload
    and     rsi, r14                       # Mask rval payload
    mov     rdi, qword ptr [rbx+0x30]      # Load rval type
    and     rdi, r13                       # Mask rval type
    mov     rcx, qword ptr [rsp+0x18+0x20] # Load scratch -> argc
    test    rax, rax
    je      interpoline_exit
    add     rsp, 0x20
    jmp     rax

interpoline_exit:
    lea     rcx, [rsp+0x20]
    call    PopActiveVMFrame
    add     rsp, 0x68+0x20
    pop     rbx
    pop     rsi
    pop     rdi
    pop     r15
    pop     r14
    pop     r13
    pop     r12
    pop     rbp
    xor     rax, rax
    ret

.globl JaegerInterpolineScripted
.def JaegerInterpolineScripted
   .scl 3
   .type 46
.endef
JaegerInterpolineScripted:
    #.ENDPROLOG
    mov     rbx, qword ptr [rbx+0x20] # Load prev
    mov     qword ptr [rsp+0x38], rbx # fp -> regs.fp
    sub     rsp, 0x20
    jmp     JaegerInterpoline

.globl JaegerInterpolinePatched
.def JaegerInterpolinePatched
   .scl 3
   .type 46
.endef
JaegerInterpolinePatched:
    sub     rsp, 0x20
    #.ALLOCSTACK 32
    #.ENDPROLOG
    jmp     JaegerInterpoline