src/runtime/sys_nacl_amd64p32.s

   1 // Copyright 2013 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 #include "zasm_GOOS_GOARCH.h"
   6 #include "textflag.h"
   7 #include "syscall_nacl.h"
   8
   9 #define NACL_SYSCALL(code) \
  10         MOVL $(0x10000 + ((code)<<5)), AX; CALL AX
  11
  12 TEXT runtime·settls(SB),NOSPLIT,$0
  13         MOVL    DI, TLS // really BP
  14         RET
  15
  16 TEXT runtime·exit(SB),NOSPLIT,$0
  17         MOVL code+0(FP), DI
  18         NACL_SYSCALL(SYS_exit)
  19         RET
  20
  21 TEXT runtime·exit1(SB),NOSPLIT,$0
  22         MOVL code+0(FP), DI
  23         NACL_SYSCALL(SYS_thread_exit)
  24         RET
  25
  26 TEXT runtime·open(SB),NOSPLIT,$0
  27         MOVL name+0(FP), DI
  28         MOVL mode+4(FP), SI
  29         MOVL perm+8(FP), DX
  30         NACL_SYSCALL(SYS_open)
  31         MOVL AX, ret+16(FP)
  32         RET
  33
  34 TEXT runtime·close(SB),NOSPLIT,$0
  35         MOVL fd+0(FP), DI
  36         NACL_SYSCALL(SYS_close)
  37         MOVL AX, ret+8(FP)
  38         RET
  39
  40 TEXT runtime·read(SB),NOSPLIT,$0
  41         MOVL fd+0(FP), DI
  42         MOVL p+4(FP), SI
  43         MOVL n+8(FP), DX
  44         NACL_SYSCALL(SYS_read)
  45         MOVL AX, ret+16(FP)
  46         RET
  47
  48 TEXT syscall·naclWrite(SB), NOSPLIT, $24-20
  49         MOVL arg1+0(FP), DI
  50         MOVL arg2+4(FP), SI
  51         MOVL arg3+8(FP), DX
  52         MOVL DI, 0(SP)
  53         MOVL SI, 4(SP)
  54         MOVL DX, 8(SP)
  55         CALL runtime·write(SB)
  56         MOVL 16(SP), AX
  57         MOVL AX, ret+16(FP)
  58         RET
  59
  60 TEXT runtime·write(SB),NOSPLIT,$16-20
  61         // If using fake time and writing to stdout or stderr,
  62         // emit playback header before actual data.
  63         MOVQ runtime·faketime(SB), AX
  64         CMPQ AX, $0
  65         JEQ write
  66         MOVL fd+0(FP), DI
  67         CMPL DI, $1
  68         JEQ playback
  69         CMPL DI, $2
  70         JEQ playback
  71
  72 write:
  73         // Ordinary write.
  74         MOVL fd+0(FP), DI
  75         MOVL p+4(FP), SI
  76         MOVL n+8(FP), DX
  77         NACL_SYSCALL(SYS_write)
  78         MOVL    AX, ret+16(FP)
  79         RET
  80
  81         // Write with playback header.
  82         // First, lock to avoid interleaving writes.
  83 playback:
  84         MOVL $1, BX
  85         XCHGL   runtime·writelock(SB), BX
  86         CMPL BX, $0
  87         JNE playback
  88
  89         // Playback header: 0 0 P B <8-byte time> <4-byte data length>
  90         MOVL $(('B'<<24) | ('P'<<16)), 0(SP)
  91         BSWAPQ AX
  92         MOVQ AX, 4(SP)
  93         MOVL n+8(FP), DX
  94         BSWAPL DX
  95         MOVL DX, 12(SP)
  96         MOVL $1, DI // standard output
  97         MOVL SP, SI
  98         MOVL $16, DX
  99         NACL_SYSCALL(SYS_write)
 100
 101         // Write actual data.
 102         MOVL $1, DI // standard output
 103         MOVL p+4(FP), SI
 104         MOVL n+8(FP), DX
 105         NACL_SYSCALL(SYS_write)
 106
 107         // Unlock.
 108         MOVL    $0, runtime·writelock(SB)
 109
 110         MOVL    AX, ret+16(FP)
 111         RET
 112
 113 TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$0
 114         MOVL p+0(FP), DI
 115         MOVL size+4(FP), SI
 116         NACL_SYSCALL(SYS_exception_stack)
 117         MOVL AX, ret+8(FP)
 118         RET
 119
 120 TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$0
 121         MOVL fn+0(FP), DI
 122         MOVL arg+4(FP), SI
 123         NACL_SYSCALL(SYS_exception_handler)
 124         MOVL AX, ret+8(FP)
 125         RET
 126
 127 TEXT runtime·nacl_sem_create(SB),NOSPLIT,$0
 128         MOVL flag+0(FP), DI
 129         NACL_SYSCALL(SYS_sem_create)
 130         MOVL AX, ret+8(FP)
 131         RET
 132
 133 TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$0
 134         MOVL sem+0(FP), DI
 135         NACL_SYSCALL(SYS_sem_wait)
 136         MOVL AX, ret+8(FP)
 137         RET
 138
 139 TEXT runtime·nacl_sem_post(SB),NOSPLIT,$0
 140         MOVL sem+0(FP), DI
 141         NACL_SYSCALL(SYS_sem_post)
 142         MOVL AX, ret+8(FP)
 143         RET
 144
 145 TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$0
 146         MOVL flag+0(FP), DI
 147         NACL_SYSCALL(SYS_mutex_create)
 148         MOVL AX, ret+8(FP)
 149         RET
 150
 151 TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$0
 152         MOVL mutex+0(FP), DI
 153         NACL_SYSCALL(SYS_mutex_lock)
 154         MOVL AX, ret+8(FP)
 155         RET
 156
 157 TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$0
 158         MOVL mutex+0(FP), DI
 159         NACL_SYSCALL(SYS_mutex_trylock)
 160         MOVL AX, ret+8(FP)
 161         RET
 162
 163 TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$0
 164         MOVL mutex+0(FP), DI
 165         NACL_SYSCALL(SYS_mutex_unlock)
 166         MOVL AX, ret+8(FP)
 167         RET
 168
 169 TEXT runtime·nacl_cond_create(SB),NOSPLIT,$0
 170         MOVL flag+0(FP), DI
 171         NACL_SYSCALL(SYS_cond_create)
 172         MOVL AX, ret+8(FP)
 173         RET
 174
 175 TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$0
 176         MOVL cond+0(FP), DI
 177         MOVL n+4(FP), SI
 178         NACL_SYSCALL(SYS_cond_wait)
 179         MOVL AX, ret+8(FP)
 180         RET
 181
 182 TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$0
 183         MOVL cond+0(FP), DI
 184         NACL_SYSCALL(SYS_cond_signal)
 185         MOVL AX, ret+8(FP)
 186         RET
 187
 188 TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$0
 189         MOVL cond+0(FP), DI
 190         NACL_SYSCALL(SYS_cond_broadcast)
 191         MOVL AX, ret+8(FP)
 192         RET
 193
 194 TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$0
 195         MOVL cond+0(FP), DI
 196         MOVL lock+4(FP), SI
 197         MOVL ts+8(FP), DX
 198         NACL_SYSCALL(SYS_cond_timed_wait_abs)
 199         MOVL AX, ret+16(FP)
 200         RET
 201
 202 TEXT runtime·nacl_thread_create(SB),NOSPLIT,$0
 203         MOVL fn+0(FP), DI
 204         MOVL stk+4(FP), SI
 205         MOVL tls+8(FP), DX
 206         MOVL xx+12(FP), CX
 207         NACL_SYSCALL(SYS_thread_create)
 208         MOVL AX, ret+16(FP)
 209         RET
 210
 211 TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 212         NACL_SYSCALL(SYS_tls_get)
 213         SUBL    $8, AX
 214         MOVL    AX, TLS
 215         JMP runtime·mstart(SB)
 216
 217 TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$0
 218         MOVL ts+0(FP), DI
 219         MOVL extra+4(FP), SI
 220         NACL_SYSCALL(SYS_nanosleep)
 221         MOVL AX, ret+8(FP)
 222         RET
 223
 224 TEXT runtime·osyield(SB),NOSPLIT,$0
 225         NACL_SYSCALL(SYS_sched_yield)
 226         RET
 227
 228 TEXT runtime·mmap(SB),NOSPLIT,$8
 229         MOVL addr+0(FP), DI
 230         MOVL n+4(FP), SI
 231         MOVL prot+8(FP), DX
 232         MOVL flags+12(FP), CX
 233         MOVL fd+16(FP), R8
 234         MOVL off+20(FP), AX
 235         MOVQ AX, 0(SP)
 236         MOVL SP, R9
 237         NACL_SYSCALL(SYS_mmap)
 238         CMPL AX, $-4095
 239         JNA 2(PC)
 240         NEGL AX
 241         MOVL    AX, ret+24(FP)
 242         RET
 243
 244 TEXT time·now(SB),NOSPLIT,$16
 245         MOVQ runtime·faketime(SB), AX
 246         CMPQ AX, $0
 247         JEQ realtime
 248         MOVQ $0, DX
 249         MOVQ $1000000000, CX
 250         DIVQ CX
 251         MOVQ AX, sec+0(FP)
 252         MOVL DX, nsec+8(FP)
 253         RET
 254 realtime:
 255         MOVL $0, DI // real time clock
 256         LEAL 0(SP), AX
 257         MOVL AX, SI // timespec
 258         NACL_SYSCALL(SYS_clock_gettime)
 259         MOVL 0(SP), AX // low 32 sec
 260         MOVL 4(SP), CX // high 32 sec
 261         MOVL 8(SP), BX // nsec
 262
 263         // sec is in AX, nsec in BX
 264         MOVL    AX, sec+0(FP)
 265         MOVL    CX, sec+4(FP)
 266         MOVL    BX, nsec+8(FP)
 267         RET
 268
 269 TEXT syscall·now(SB),NOSPLIT,$0
 270         JMP time·now(SB)
 271
 272 TEXT runtime·nacl_clock_gettime(SB),NOSPLIT,$0
 273         MOVL arg1+0(FP), DI
 274         MOVL arg2+4(FP), SI
 275         NACL_SYSCALL(SYS_clock_gettime)
 276         MOVL AX, ret+8(FP)
 277         RET
 278
 279 TEXT runtime·nanotime(SB),NOSPLIT,$16
 280         MOVQ runtime·faketime(SB), AX
 281         CMPQ AX, $0
 282         JEQ 3(PC)
 283         MOVQ    AX, ret+0(FP)
 284         RET
 285         MOVL $0, DI // real time clock
 286         LEAL 0(SP), AX
 287         MOVL AX, SI // timespec
 288         NACL_SYSCALL(SYS_clock_gettime)
 289         MOVQ 0(SP), AX // sec
 290         MOVL 8(SP), DX // nsec
 291
 292         // sec is in AX, nsec in DX
 293         // return nsec in AX
 294         IMULQ   $1000000000, AX
 295         ADDQ    DX, AX
 296         MOVQ    AX, ret+0(FP)
 297         RET
 298
 299 TEXT runtime·sigtramp(SB),NOSPLIT,$80
 300         // restore TLS register at time of execution,
 301         // in case it's been smashed.
 302         // the TLS register is really BP, but for consistency
 303         // with non-NaCl systems it is referred to here as TLS.
 304         // NOTE: Cannot use SYS_tls_get here (like we do in mstart_nacl),
 305         // because the main thread never calls tls_set.
 306         LEAL ctxt+0(FP), AX
 307         MOVL (16*4+5*8)(AX), AX
 308         MOVL    AX, TLS
 309
 310         // check that g exists
 311         get_tls(CX)
 312         MOVL    g(CX), DI
 313
 314         CMPL    DI, $0
 315         JEQ     nog
 316
 317         // save g
 318         MOVL    DI, 20(SP)
 319
 320         // g = m->gsignal
 321         MOVL    g_m(DI), BX
 322         MOVL    m_gsignal(BX), BX
 323         MOVL    BX, g(CX)
 324
 325 //JMP debughandler
 326
 327         // copy arguments for sighandler
 328         MOVL    $11, 0(SP) // signal
 329         MOVL    $0, 4(SP) // siginfo
 330         LEAL    ctxt+0(FP), AX
 331         MOVL    AX, 8(SP) // context
 332         MOVL    DI, 12(SP) // g
 333
 334         CALL    runtime·sighandler(SB)
 335
 336         // restore g
 337         get_tls(CX)
 338         MOVL    20(SP), BX
 339         MOVL    BX, g(CX)
 340
 341         // Enable exceptions again.
 342         NACL_SYSCALL(SYS_exception_clear_flag)
 343
 344         // Restore registers as best we can. Impossible to do perfectly.
 345         // See comment in sys_nacl_386.s for extended rationale.
 346         LEAL    ctxt+0(FP), SI
 347         ADDL    $64, SI
 348         MOVQ    0(SI), AX
 349         MOVQ    8(SI), CX
 350         MOVQ    16(SI), DX
 351         MOVQ    24(SI), BX
 352         MOVL    32(SI), SP      // MOVL for SP sandboxing
 353         // 40(SI) is saved BP aka TLS, already restored above
 354         // 48(SI) is saved SI, never to be seen again
 355         MOVQ    56(SI), DI
 356         MOVQ    64(SI), R8
 357         MOVQ    72(SI), R9
 358         MOVQ    80(SI), R10
 359         MOVQ    88(SI), R11
 360         MOVQ    96(SI), R12
 361         MOVQ    104(SI), R13
 362         MOVQ    112(SI), R14
 363         // 120(SI) is R15, which is owned by Native Client and must not be modified
 364         MOVQ    128(SI), SI // saved PC
 365         // 136(SI) is saved EFLAGS, never to be seen again
 366         JMP     SI
 367
 368 debughandler:
 369         // print basic information
 370         LEAL    ctxt+0(FP), DI
 371         MOVL    $runtime·sigtrampf(SB), AX
 372         MOVL    AX, 0(SP)
 373         MOVQ    (16*4+16*8)(DI), BX // rip
 374         MOVQ    BX, 8(SP)
 375         MOVQ    (16*4+0*8)(DI), BX // rax
 376         MOVQ    BX, 16(SP)
 377         MOVQ    (16*4+1*8)(DI), BX // rcx
 378         MOVQ    BX, 24(SP)
 379         MOVQ    (16*4+2*8)(DI), BX // rdx
 380         MOVQ    BX, 32(SP)
 381         MOVQ    (16*4+3*8)(DI), BX // rbx
 382         MOVQ    BX, 40(SP)
 383         MOVQ    (16*4+7*8)(DI), BX // rdi
 384         MOVQ    BX, 48(SP)
 385         MOVQ    (16*4+15*8)(DI), BX // r15
 386         MOVQ    BX, 56(SP)
 387         MOVQ    (16*4+4*8)(DI), BX // rsp
 388         MOVQ    0(BX), BX
 389         MOVQ    BX, 64(SP)
 390         CALL    runtime·printf(SB)
 391
 392         LEAL    ctxt+0(FP), DI
 393         MOVQ    (16*4+16*8)(DI), BX // rip
 394         MOVL    BX, 0(SP)
 395         MOVQ    (16*4+4*8)(DI), BX // rsp
 396         MOVL    BX, 4(SP)
 397         MOVL    $0, 8(SP)       // lr
 398         get_tls(CX)
 399         MOVL    g(CX), BX
 400         MOVL    BX, 12(SP)      // gp
 401         CALL    runtime·traceback(SB)
 402
 403 notls:
 404         MOVL    0, AX
 405         RET
 406
 407 nog:
 408         MOVL    0, AX
 409         RET
 410
 411 // cannot do real signal handling yet, because gsignal has not been allocated.
 412 MOVL $1, DI; NACL_SYSCALL(SYS_exit)
 413
 414 TEXT runtime·nacl_sysinfo(SB),NOSPLIT,$16
 415 /*
 416         MOVL    di+0(FP), DI
 417         LEAL    12(DI), BX
 418         MOVL    8(DI), AX
 419         ADDL    4(DI), AX
 420         ADDL    $2, AX
 421         LEAL    (BX)(AX*4), BX
 422         MOVL    BX, runtime·nacl_irt_query(SB)
 423 auxloop:
 424         MOVL    0(BX), DX
 425         CMPL    DX, $0
 426         JNE     2(PC)
 427         RET
 428         CMPL    DX, $32
 429         JEQ     auxfound
 430         ADDL    $8, BX
 431         JMP     auxloop
 432 auxfound:
 433         MOVL    4(BX), BX
 434         MOVL    BX, runtime·nacl_irt_query(SB)
 435
 436         LEAL    runtime·nacl_irt_basic_v0_1_str(SB), DI
 437         LEAL    runtime·nacl_irt_basic_v0_1(SB), SI
 438         MOVL    runtime·nacl_irt_basic_v0_1_size(SB), DX
 439         MOVL    runtime·nacl_irt_query(SB), BX
 440         CALL    BX
 441
 442         LEAL    runtime·nacl_irt_memory_v0_3_str(SB), DI
 443         LEAL    runtime·nacl_irt_memory_v0_3(SB), SI
 444         MOVL    runtime·nacl_irt_memory_v0_3_size(SB), DX
 445         MOVL    runtime·nacl_irt_query(SB), BX
 446         CALL    BX
 447
 448         LEAL    runtime·nacl_irt_thread_v0_1_str(SB), DI
 449         LEAL    runtime·nacl_irt_thread_v0_1(SB), SI
 450         MOVL    runtime·nacl_irt_thread_v0_1_size(SB), DX
 451         MOVL    runtime·nacl_irt_query(SB), BX
 452         CALL    BX
 453
 454         // TODO: Once we have a NaCl SDK with futex syscall support,
 455         // try switching to futex syscalls and here load the
 456         // nacl-irt-futex-0.1 table.
 457 */
 458         RET