src/vm/jit/x86_64/asmpart.S

   1 /* src/vm/jit/x86_64/asmpart.S - Java-C interface functions for x86_64
   2
   3    Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
   4    R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
   5    C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
   6    Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    Contact: cacao@complang.tuwien.ac.at
  26
  27    Authors: Andreas Krall
  28             Reinhard Grafl
  29             Christian Thalinger
  30
  31    Changes:
  32
  33    $Id: asmpart.S 3891 2005-12-05 22:54:42Z twisti $
  34
  35 */
  36
  37
  38 #include "config.h"
  39
  40 #include "md-abi.h"
  41 #include "md-asm.h"
  42
  43 #include "vm/jit/x86_64/arch.h"
  44 #include "vm/jit/x86_64/offsets.h"
  45
  46 #include "vm/jit/methodheader.h"
  47
  48
  49         .text
  50
  51
  52 /********************* exported functions and variables ***********************/
  53
  54         .globl asm_calljavafunction
  55         .globl asm_calljavafunction_int
  56
  57         .globl asm_calljavafunction2
  58         .globl asm_calljavafunction2int
  59         .globl asm_calljavafunction2long
  60         .globl asm_calljavafunction2float
  61         .globl asm_calljavafunction2double
  62
  63         .globl asm_call_jit_compiler
  64         .globl asm_handle_exception
  65         .globl asm_handle_nat_exception
  66
  67         .globl asm_wrapper_patcher
  68
  69         .globl asm_builtin_f2i
  70         .globl asm_builtin_f2l
  71         .globl asm_builtin_d2i
  72         .globl asm_builtin_d2l
  73
  74         .globl asm_perform_threadswitch
  75         .globl asm_initialize_thread_stack
  76         .globl asm_switchstackandcall
  77         .globl asm_criticalsections
  78         .globl asm_getclassvalues_atomic
  79
  80
  81 /********************* function asm_calljavafunction ***************************
  82 *                                                                              *
  83 *   This function calls a Java-method (which possibly needs compilation)       *
  84 *   with up to 4 address parameters.                                           *
  85 *                                                                              *
  86 *   This functions calls the JIT-compiler which eventually translates the      *
  87 *   method into machine code.                                                  *
  88 *                                                                              *
  89 *   C-prototype:                                                               *
  90 *    javaobject_header *asm_calljavamethod (methodinfo *m,                     *
  91 *         void *arg1, void *arg2, void *arg3, void *arg4);                     *
  92 *                                                                              *
  93 *******************************************************************************/
  94
  95 call_name:
  96         .align  8
  97
  98         .quad   0                         /* catch type all                       */
  99         .quad   calljava_xhandler         /* handler pc                           */
 100         .quad   calljava_xhandler         /* end pc                               */
 101         .quad   asm_calljavafunction      /* start pc                             */
 102         .long   1                         /* extable size                         */
 103         .long   0
 104         .quad   0                         /* line number table start              */
 105         .quad   0                         /* line number table size               */
 106         .long   0
 107         .long   0                         /* fltsave                              */
 108         .long   0                         /* intsave                              */
 109         .long   0                         /* isleaf                               */
 110         .long   0                         /* IsSync                               */
 111         .long   8                         /* frame size                           */
 112         .quad   0                         /* method pointer (pointer to name)     */
 113
 114 asm_calljavafunction:
 115 asm_calljavafunction_int:
 116         sub     $(3*8),%rsp               /* keep stack 16-byte aligned           */
 117         mov     %rbp,0*8(%rsp)
 118         mov     %rbx,1*8(%rsp)            /* %rbx is not a callee saved in cacao  */
 119         mov     %rdi,%rax                 /* move function pointer to %rax        */
 120                                                                           /* compilerstub uses this               */
 121
 122         mov     %rsi,%rdi                 /* pass remaining parameters            */
 123         mov     %rdx,%rsi
 124         mov     %rcx,%rdx
 125         mov     %r8,%rcx
 126
 127         lea     asm_call_jit_compiler,%r11
 128         call    *%r11                     /* call JIT compiler                    */
 129
 130         mov     0*8(%rsp),%rbp
 131         mov             1*8(%rsp),%rbx
 132         add     $(3*8),%rsp               /* free stack space                     */
 133         ret
 134
 135 calljava_xhandler:
 136         mov     %rax,%rdi                 /* pass exception pointer               */
 137         call    builtin_throw_exception
 138         mov     0*8(%rsp),%rbp
 139         mov             1*8(%rsp),%rbx
 140         add     $(3*8),%rsp
 141         xor     %rax,%rax                 /* return NULL                          */
 142         ret
 143
 144
 145 /********************* function asm_calljavafunction ***************************
 146 *                                                                              *
 147 *   This function calls a Java-method (which possibly needs compilation)       *
 148 *   with up to 4 address parameters.                                           *
 149 *                                                                              *
 150 *   This functions calls the JIT-compiler which eventually translates the      *
 151 *   method into machine code.                                                  *
 152 *                                                                              *
 153 *   C-prototype:                                                               *
 154 *    javaobject_header *asm_calljavamethod (methodinfo *m,                     *
 155 *         void *arg1, void *arg2, void *arg3, void *arg4);                     *
 156 *                                                                              *
 157 *******************************************************************************/
 158
 159 call_name2:
 160         .align  8
 161
 162         .quad   0                         /* catch type all                       */
 163         .quad   calljava_xhandler2        /* handler pc                           */
 164         .quad   calljava_xhandler2        /* end pc                               */
 165         .quad   asm_calljavafunction2     /* start pc                             */
 166         .long   1                         /* extable size                         */
 167         .long   0
 168         .quad   0                         /* line number table  start             */
 169         .quad   0                         /* line number table  size              */
 170         .long   0
 171         .long   0                         /* fltsave                              */
 172         .long   0                         /* intsave                              */
 173         .long   0                         /* isleaf                               */
 174         .long   0                         /* IsSync                               */
 175         .long   24                        /* frame size                           */
 176         .quad   0                         /* method pointer (pointer to name)     */
 177
 178 asm_calljavafunction2:
 179 asm_calljavafunction2int:
 180 asm_calljavafunction2long:
 181 asm_calljavafunction2float:
 182 asm_calljavafunction2double:
 183         sub     $(7*8),%rsp               /* keep stack 16-byte aligned           */
 184         mov     %rbx,0*8(%rsp)            /* %rbx is not a callee saved in cacao  */
 185         mov     %rbp,1*8(%rsp)
 186         mov     %r12,2*8(%rsp)
 187         mov     %r13,3*8(%rsp)
 188         mov     %r14,4*8(%rsp)
 189         mov     %r15,5*8(%rsp)
 190
 191         mov     %rdi,%rax                 /* move method pointer for compiler     */
 192         xor     %rbp,%rbp                 /* set argument stack frame to zero     */
 193
 194         test    %rsi,%rsi                 /* maybe we have no args...             */
 195         jle     L_copy_done
 196
 197         mov     %rsi,itmp3                /* arg count                            */
 198         mov     %rcx,itmp2                /* pointer to arg block                 */
 199
 200         mov     itmp2,%r14                /* save argument block pointer          */
 201         mov     itmp3,%r15                /* save argument count                  */
 202
 203         sub     $sizejniblock,itmp2       /* initialize pointer (smaller code)    */
 204         add     $1,itmp3                  /* initialize argument count            */
 205         xor     %r12,%r12                 /* initialize integer argument counter  */
 206         xor     %r13,%r13                 /* initialize float argument counter    */
 207
 208 L_register_copy:
 209         add     $sizejniblock,itmp2       /* goto next argument block             */
 210         dec     itmp3                     /* argument count - 1                   */
 211         jz      L_register_copy_done
 212         andb    $0x02,offjniitemtype(itmp2) /* is this a float/double type?       */
 213         jnz     L_register_handle_float   /* yes, handle it                       */
 214
 215         cmp     $INT_ARG_CNT,%r12         /* are we out of integer argument       */
 216         je      L_register_copy           /* register? yes, next loop             */
 217
 218         lea     jumptable_integer,%rbp
 219         mov     0(%rbp,%r12,8),%rbx
 220         inc     %r12                      /* integer argument counter + 1         */
 221         jmp     *%rbx
 222
 223 L_register_handle_float:
 224         cmp     $FLT_ARG_CNT,%r13         /* are we out of float argument         */
 225         je      L_register_copy           /* register? yes, next loop             */
 226
 227         lea     jumptable_float,%rbp
 228         mov     0(%rbp,%r13,8),%rbx
 229         inc     %r13                      /* float argument counter + 1           */
 230         jmp     *%rbx
 231
 232 L_register_copy_done:
 233         mov     %r15,%rbp                 /* calculate remaining arguments        */
 234         sub     %r12,%rbp                 /* - integer arguments in registers     */
 235         sub     %r13,%rbp                 /* - float arguments in registers       */
 236         jle     L_copy_done               /* are all assigned to registers?       */
 237
 238         and     $0xfffffffffffffffe,%rbp  /* keep stack 16-byte aligned           */
 239         shl     $3,%rbp                   /* calculate stack size                 */
 240         sub     %rbp,%rsp                 /* stack frame for arguments            */
 241         mov     %rsp,%rbx                 /* use %rbx as temp sp                  */
 242
 243         sub     $sizejniblock,%r14        /* initialize pointer (smaller code)    */
 244         add     $1,%r15                   /* initialize argument count            */
 245
 246 L_stack_copy_loop:
 247         add     $sizejniblock,%r14        /* goto next argument block             */
 248         dec     %r15                      /* are there any arguments left?        */
 249         jz      L_copy_done               /* no test needed after dec             */
 250
 251         andb    $0x02,offjniitemtype(%r14) /* is this a float/double type?        */
 252         jnz     L_stack_handle_float
 253         dec     %r12                      /* arguments assigned to registers      */
 254         jge     L_stack_copy_loop
 255         jmp     L_stack_copy
 256
 257 L_stack_handle_float:
 258         dec     %r13                      /* arguments assigned to registers      */
 259         jge     L_stack_copy_loop
 260
 261 L_stack_copy:
 262     mov     offjniitem(%r14),itmp3    /* copy s8 argument onto stack          */
 263     mov     itmp3,0(%rbx)
 264     add     $8,%rbx                   /* increase sp to next argument         */
 265         jmp     L_stack_copy_loop
 266
 267 L_copy_done:
 268         lea     asm_call_jit_compiler,%r11/* %rax still contains method pointer   */
 269         call    *%r11                     /* call JIT compiler                    */
 270
 271         add     %rbp,%rsp                 /* remove argument stack frame if any   */
 272
 273         mov     5*8(%rsp),%r15            /* restore callee saved registers       */
 274         mov     4*8(%rsp),%r14
 275         mov     3*8(%rsp),%r13
 276         mov     2*8(%rsp),%r12
 277         mov     1*8(%rsp),%rbp
 278         mov     0*8(%rsp),%rbx
 279         add     $(7*8),%rsp               /* free stack space                     */
 280         ret
 281
 282 calljava_xhandler2:
 283         mov     %rax,%rdi                 /* pass exception pointer               */
 284         call    builtin_throw_exception
 285
 286         mov     5*8(%rsp),%r15            /* restore callee saved registers       */
 287         mov     4*8(%rsp),%r14
 288         mov     3*8(%rsp),%r13
 289         mov     2*8(%rsp),%r12
 290         mov     1*8(%rsp),%rbp
 291         mov     0*8(%rsp),%rbx
 292         add     $(7*8),%rsp               /* free stack space                     */
 293         xor     %rax,%rax                 /* return NULL                          */
 294         ret
 295
 296
 297 jumptable_integer:
 298         .quad   handle_a0
 299         .quad   handle_a1
 300         .quad   handle_a2
 301         .quad   handle_a3
 302         .quad   handle_a4
 303         .quad   handle_a5
 304
 305 handle_a0:
 306         mov     offjniitem(itmp2),a0
 307         jmp     L_register_copy
 308 handle_a1:
 309         mov     offjniitem(itmp2),a1
 310         jmp     L_register_copy
 311 handle_a2:
 312         mov     offjniitem(itmp2),a2
 313         jmp     L_register_copy
 314 handle_a3:
 315         mov     offjniitem(itmp2),a3
 316         jmp     L_register_copy
 317 handle_a4:
 318         mov     offjniitem(itmp2),a4
 319         jmp     L_register_copy
 320 handle_a5:
 321         mov     offjniitem(itmp2),a5
 322         jmp     L_register_copy
 323
 324
 325 jumptable_float:
 326         .quad   handle_fa0
 327         .quad   handle_fa1
 328         .quad   handle_fa2
 329         .quad   handle_fa3
 330         .quad   handle_fa4
 331         .quad   handle_fa5
 332         .quad   handle_fa6
 333         .quad   handle_fa7
 334
 335 handle_fa0:
 336         movq    offjniitem(itmp2),fa0
 337         jmp     L_register_copy
 338 handle_fa1:
 339         movq    offjniitem(itmp2),fa1
 340         jmp     L_register_copy
 341 handle_fa2:
 342         movq    offjniitem(itmp2),fa2
 343         jmp     L_register_copy
 344 handle_fa3:
 345         movq    offjniitem(itmp2),fa3
 346         jmp     L_register_copy
 347 handle_fa4:
 348         movq    offjniitem(itmp2),fa4
 349         jmp     L_register_copy
 350 handle_fa5:
 351         movq    offjniitem(itmp2),fa5
 352         jmp     L_register_copy
 353 handle_fa6:
 354         movq    offjniitem(itmp2),fa6
 355         jmp     L_register_copy
 356 handle_fa7:
 357         movq    offjniitem(itmp2),fa7
 358         jmp     L_register_copy
 359
 360
 361 /****************** function asm_call_jit_compiler *****************************
 362 *                                                                              *
 363 *   invokes the compiler for untranslated JavaVM methods.                      *
 364 *                                                                              *
 365 *   Register R0 contains a pointer to the method info structure (prepared      *
 366 *   by createcompilerstub). Using the return address in R26 and the            *
 367 *   offset in the LDA instruction or using the value in methodptr R28 the      *
 368 *   patching address for storing the method address can be computed:           *
 369 *                                                                              *
 370 *   method address was either loaded using                                     *
 371 *                                                                              *
 372 *   i386_mov_imm_reg(a, REG_ITMP2)                ; invokestatic/special       *
 373 *   i386_call_reg(REG_ITMP2)                                                   *
 374 *                                                                              *
 375 *   or                                                                         *
 376 *                                                                              *
 377 *   i386_mov_membase_reg(REG_SP, 0, REG_ITMP2)    ; invokevirtual/interface    *
 378 *   i386_mov_membase_reg(REG_ITMP2, OFFSET(, vftbl), REG_ITMP3)                *
 379 *   i386_mov_membase_reg(REG_ITMP3, OFFSET(vftbl, table[0]) + \                *
 380 *       sizeof(methodptr) * m->vftblindex, REG_ITMP1)                          *
 381 *   i386_call_reg(REG_ITMP1)                                                   *
 382 *                                                                              *
 383 *   in the static case the method pointer can be computed using the            *
 384 *   return address and the lda function following the jmp instruction          *
 385 *                                                                              *
 386 *******************************************************************************/
 387
 388 asm_call_jit_compiler:
 389         sub     $((3+24)*8+sizestackframeinfo),sp /* keep stack 16-byte aligned   */
 390
 391         mov     %rbx,0*8(%rsp)              /* save register                      */
 392
 393         mov     (3+24)*8+sizestackframeinfo(%rsp),itmp3 /* get return address     */
 394         mov     -1(itmp3),%bl               /* get function code                  */
 395         cmp     $0xd2,%bl                   /* called with `call *REG_ITMP2'?     */
 396         jne     L_not_static_special
 397
 398         sub     $11,itmp3                   /* calculate address of immediate     */
 399         jmp     L_call_jit_compile
 400
 401 L_not_static_special:
 402         cmp     $0xd0,%bl           /* called with `call *REG_ITMP1' (%rax)       */
 403         jne     L_not_virtual_interface
 404
 405         sub     $7,itmp3            /* calculate address of offset                */
 406         mov     (itmp3),itmp3l      /* get offset (32-bit)                        */
 407         add     itmp2,itmp3         /* add base address to get method address     */
 408         jmp     L_call_jit_compile
 409
 410 L_not_virtual_interface:        /* a call from asm_calljavamethod             */
 411         xor     itmp3,itmp3
 412
 413 L_call_jit_compile:
 414         mov     0*8(sp),%rbx                /* restore register                   */
 415         mov     itmp3,0*8(sp)               /* save address for method pointer    */
 416         mov     itmp1,1*8(sp)               /* save method pointer                */
 417
 418         SAVE_ARGUMENT_REGISTERS(2)
 419
 420         mov     sp,a0                       /* create stackframe info             */
 421         add     $((3+24)*8),a0              /* pass sfi                           */
 422         xor     a1,a1                       /* if pv is NULL, use findmethod      */
 423         mov     sp,a2                       /* pass java sp                       */
 424         add     $((1+3+24)*8+sizestackframeinfo),a2
 425         mov     ((3+24)*8+sizestackframeinfo)(sp),a3 /* pass ra to java function  */
 426         mov     a3,a4                       /* xpc is equal to ra                 */
 427         call    stacktrace_create_extern_stackframeinfo
 428
 429         mov     1*8(sp),a0                  /* pass method pointer                */
 430         call    jit_compile
 431         mov     v0,1*8(sp)                  /* save return value                  */
 432
 433         mov     sp,a0                       /* remove stackframe info             */
 434         add     $((3+24)*8),a0              /* pass sfi                           */
 435         call    stacktrace_remove_stackframeinfo
 436
 437         mov     0*8(sp),itmp3               /* restore address for method pointer */
 438         mov     1*8(sp),v0                  /* restore return value               */
 439
 440         RESTORE_ARGUMENT_REGISTERS(2)
 441
 442         add     $((3+24)*8+sizestackframeinfo),sp /* remove stack frame           */
 443
 444         test    v0,v0                       /* check for exception                */
 445         je      L_asm_call_jit_compiler_exception
 446
 447         test    %r11,%r11                   /* is address == 0 (asm_calljavamethod*/
 448         je      L_call_method
 449
 450         mov     %rax,(%r11)                 /* and now save the new pointer       */
 451
 452 L_call_method:
 453         jmp     *%rax                       /* ...and now call the new method     */
 454
 455 L_asm_call_jit_compiler_exception:
 456 #if defined(USE_THREADS) && defined(NATIVE_THREADS)
 457         call    builtin_asm_get_exceptionptrptr
 458         mov     v0,itmp2                    /* v0 == xptr                         */
 459 #else
 460         lea     _no_threads_exceptionptr,itmp2
 461 #endif
 462         mov     (itmp2),xptr                /* get the exception pointer          */
 463         movl    $0,(itmp2)                  /* clear exception pointer            */
 464
 465         pop     xpc                         /* delete return address              */
 466         sub     $5,xpc                      /* faulting address is ra - 5         */
 467         jmp     asm_handle_exception
 468
 469
 470 /********************* function asm_handle_exception ***************************
 471 *                                                                              *
 472 *   This function handles an exception. It does not use the usual calling      *
 473 *   conventions. The exception pointer is passed in REG_ITMP1 and the          *
 474 *   pc from the exception raising position is passed in REG_ITMP2. It searches *
 475 *   the local exception table for a handler. If no one is found, it unwinds    *
 476 *   stacks and continues searching the callers.                                *
 477 *                                                                              *
 478 *   void asm_handle_exception (exceptionptr, exceptionpc);                     *
 479 *                                                                              *
 480 *******************************************************************************/
 481
 482 asm_handle_nat_exception:
 483         add     $8,%rsp                     /* clear return address of native stub*/
 484
 485 asm_handle_exception:
 486         sub     $(4*8),%rsp
 487         mov     xptr,0*8(%rsp)              /* save exception pointer             */
 488         mov     xpc,1*8(%rsp)               /* save exception pc                  */
 489
 490         mov     xpc,%rdi                    /* exception pc                       */
 491         call    codegen_findmethod
 492         mov     %rax,itmp3
 493         mov     %rax,2*8(%rsp)              /* save data segment pointer          */
 494
 495         mov     0*8(%rsp),%rax              /* restore exception pointer          */
 496         mov     1*8(%rsp),%r10              /* restore exception pc               */
 497
 498         xor     a3,a3                       /* clear indent flag (only first time)*/
 499
 500 ex_stack_loop:
 501         mov     0*8(sp),a0                  /* pass exception pointer             */
 502         mov     1*8(sp),a1                  /* pass exception pc                  */
 503         mov     2*8(sp),a2                  /* pass data segment pointer          */
 504         call    exceptions_handle_exception
 505
 506         test    v0,v0
 507         jz      L_asm_handle_exception_not_catched
 508
 509         mov     v0,xpc                      /* move handlerpc into xpc            */
 510         mov     0*8(sp),%rax                /* restore exception pointer          */
 511         add     $(4*8),sp                   /* free stack frame                   */
 512
 513         jmp     *xpc                        /* jump to the handler                */
 514
 515 L_asm_handle_exception_not_catched:
 516         mov     0*8(%rsp),%rax              /* restore exception pointer          */
 517         mov     1*8(%rsp),%r10              /* restore exception pc               */
 518         mov     2*8(%rsp),%r11              /* restore data segment pointer       */
 519         add     $(4*8),%rsp
 520
 521         mov     %rax,%rcx                   /* save exception pointer             */
 522
 523 ex_already_cleared:
 524         movl    IsSync(%r11),%eax           /* %rax = SyncOffset                  */
 525         test    %rax,%rax                   /* if zero no monitorexit             */
 526         je      no_monitor_exit
 527
 528 #if defined(USE_THREADS)
 529         add     %rsp,%rax
 530         mov     -8(%rax),%rdi               /* get monitor object from stack      */
 531
 532         sub     $(4*8),%rsp
 533         mov     %rcx,0*8(%rsp)
 534         mov     %r10,1*8(%rsp)
 535         mov     %r11,2*8(%rsp)
 536
 537         call    builtin_monitorexit
 538
 539         mov     0*8(%rsp),%rcx
 540         mov     1*8(%rsp),%r10
 541         mov     2*8(%rsp),%r11
 542         add     $(4*8),%rsp
 543 #endif
 544
 545 no_monitor_exit:
 546         mov     FrameSize(%r11),%eax        /* %eax = frame size                  */
 547         add     %rax,%rsp                   /* unwind stack                       */
 548         mov     %rsp,%rax                   /* %rax = pointer to save area        */
 549
 550         mov     IntSave(%r11),%edx          /* %edx = saved int register count    */
 551         test    %edx,%edx
 552         je      noint
 553
 554         cmp     $1,%edx
 555         je      int1
 556         cmp     $2,%edx
 557         je      int2
 558         cmp     $3,%edx
 559         je      int3
 560         cmp     $4,%edx
 561         je      int4
 562         cmp     $5,%edx
 563         je      int5
 564
 565         mov     -48(%rax),%rbx
 566 int5:
 567         mov     -40(%rax),%rbp
 568 int4:
 569         mov     -32(%rax),%r12
 570 int3:
 571         mov     -24(%rax),%r13
 572 int2:
 573         mov     -16(%rax),%r14
 574 int1:
 575         mov     -8(%rax),%r15
 576
 577         shl     $3,%edx                     /* multiply by 8 bytes                */
 578         sub     %rdx,%rax
 579
 580 noint:
 581         mov     FltSave(%r11),%edx          /* %edx = saved flt register count    */
 582         test    %edx,%edx
 583         je      noflt
 584
 585         cmpl    $1,%edx
 586         je      flt1
 587         cmpl    $2,%edx
 588         je      flt2
 589         cmpl    $3,%edx
 590         je      flt3
 591         cmpl    $4,%edx
 592         je      flt4
 593         cmpl    $5,%edx
 594         je      flt5
 595         cmpl    $6,%edx
 596         je      flt7
 597         cmpl    $7,%edx
 598         je      flt7
 599
 600         movq    -64(%rax),%xmm8
 601 flt7:
 602         movq    -56(%rax),%xmm9
 603 flt6:
 604         movq    -48(%rax),%xmm10
 605 flt5:
 606         movq    -40(%rax),%xmm11
 607 flt4:
 608         movq    -32(%rax),%xmm12
 609 flt3:
 610         movq    -24(%rax),%xmm13
 611 flt2:
 612         movq    -16(%rax),%xmm14
 613 flt1:
 614         movq    -8(%rax),%xmm15
 615
 616 noflt:
 617         pop     %r10                        /* the new xpc is return address      */
 618         sub     $3,%r10                     /* subtract 3 bytes for call          */
 619
 620         sub     $(2*8),%rsp
 621         mov     %rcx,0*8(%rsp)
 622         mov     %r10,1*8(%rsp)
 623
 624         mov     %r10,%rdi
 625         call    codegen_findmethod          /* get the new data segment ptr       */
 626         mov     %rax,%r11
 627
 628         mov     0*8(%rsp),%rcx
 629         mov     1*8(%rsp),%r10
 630         add     $(2*8),%rsp
 631
 632         mov     %rcx,%rax                                       /* restore saved exception pointer    */
 633
 634         sub     $(4*8),%rsp
 635
 636         mov     %rax,0*8(%rsp)              /* save exception pointer             */
 637         mov     %r10,1*8(%rsp)              /* save exception pc                  */
 638         mov     %r11,2*8(%rsp)                          /* save data segment pointer          */
 639
 640         mov     $1,a3                       /* set indent flag                    */
 641
 642         jmp             ex_stack_loop
 643
 644
 645 /* asm_wrapper_patcher *********************************************************
 646
 647    XXX
 648
 649    Stack layout:
 650      40   return address
 651      32   pointer to virtual java_objectheader
 652      24   machine code (which is patched back later)
 653      16   unresolved class/method/field reference
 654       8   data segment displacement from load instructions
 655       0   pointer to patcher function
 656      -8   bp
 657
 658 *******************************************************************************/
 659
 660 asm_wrapper_patcher:
 661         push    bp                          /* save base pointer                  */
 662         mov     sp,bp                       /* move actual sp to bp               */
 663         sub     $(18*8+sizestackframeinfo),sp /* stack frame (16-byte aligned)    */
 664         and     $0xfffffffffffffff0,sp      /* align sp to 16-byte (this is for   */
 665                                             /* leaf functions)                    */
 666
 667         SAVE_ARGUMENT_REGISTERS(0)
 668         SAVE_TEMPORARY_REGISTERS(14)
 669
 670         mov     itmp1,15*8(sp)              /* save itmp1 and itmp2               */
 671         mov     itmp2,16*8(sp)              /* can be used by some instructions   */
 672
 673         mov     sp,a0                       /* create stackframe info             */
 674         add     $(18*8),a0
 675         xor     a1,a1                       /* if pv is NULL, use findmethod      */
 676         mov     bp,a2                       /* pass java sp                       */
 677         add     $((6+1)*8),a2
 678         mov     ((5+1)*8)(bp),a3            /* pass ra to java function           */
 679         mov     a3,a4                       /* xpc is equal to ra                 */
 680         call    stacktrace_create_extern_stackframeinfo
 681
 682         mov     bp,a0                       /* pass stack pointer                 */
 683         add     $((1+1)*8),a0               /* skip function pointer              */
 684         mov     1*8(bp),itmp3               /* get function pointer               */
 685         call    *itmp3                      /* call the patcher function          */
 686         mov     v0,17*8(sp)                 /* save return value                  */
 687
 688         mov     sp,a0                       /* remove stackframe info             */
 689         add     $(18*8),a0
 690         call    stacktrace_remove_stackframeinfo
 691
 692         RESTORE_ARGUMENT_REGISTERS(0)
 693         RESTORE_TEMPORARY_REGISTERS(14)
 694
 695         mov     15*8(sp),itmp1              /* restore itmp1 and itmp2            */
 696         mov     16*8(sp),itmp2              /* can be used by some instructions   */
 697         mov     17*8(sp),itmp3              /* restore return value               */
 698
 699         mov     bp,sp                       /* restore original sp                */
 700         pop     bp                          /* restore bp                         */
 701         add     $(5*8),sp                   /* remove patcher stackframe, keep ra */
 702
 703         test    itmp3,itmp3                 /* exception thrown?                  */
 704         jz      L_asm_wrapper_patcher_exception
 705         ret                                 /* call new patched code              */
 706
 707 L_asm_wrapper_patcher_exception:
 708 #if defined(USE_THREADS) && defined(NATIVE_THREADS)
 709         call    builtin_asm_get_exceptionptrptr
 710         mov     v0,itmp2                    /* v0 == xptr                         */
 711 #else
 712         lea     _no_threads_exceptionptr,itmp2
 713 #endif
 714         mov     (itmp2),xptr                /* get the exception pointer          */
 715         movl    $0,(itmp2)                  /* clear exception pointer            */
 716
 717         pop     xpc                         /* get and remove return address      */
 718         jmp     asm_handle_exception
 719
 720
 721 /* asm_builtin_x2x *************************************************************
 722 *                                                                              *
 723 *   Wrapper functions for float to int corner cases                            *
 724 *                                                                              *
 725 *******************************************************************************/
 726
 727 asm_builtin_f2i:
 728         sub     $(14*8),%rsp
 729
 730         SAVE_ARGUMENT_REGISTERS(0)
 731
 732         movq    %xmm8,%xmm0
 733         call    builtin_f2i
 734
 735         RESTORE_ARGUMENT_REGISTERS(0)
 736
 737         add     $(14*8),%rsp
 738         ret
 739
 740
 741 asm_builtin_f2l:
 742         sub     $(14*8),%rsp
 743
 744         SAVE_ARGUMENT_REGISTERS(0)
 745
 746         movq    %xmm8,%xmm0
 747         call    builtin_f2l
 748
 749         RESTORE_ARGUMENT_REGISTERS(0)
 750
 751         add     $(14*8),%rsp
 752         ret
 753
 754
 755 asm_builtin_d2i:
 756         sub     $(14*8),%rsp
 757
 758         SAVE_ARGUMENT_REGISTERS(0)
 759
 760         movq    %xmm8,%xmm0
 761         call    builtin_d2i
 762
 763         RESTORE_ARGUMENT_REGISTERS(0)
 764
 765         add     $(14*8),%rsp
 766         ret
 767
 768
 769 asm_builtin_d2l:
 770         sub     $(14*8),%rsp
 771
 772         SAVE_ARGUMENT_REGISTERS(0)
 773
 774         movq    %xmm8,%xmm0
 775         call    builtin_d2l
 776
 777         RESTORE_ARGUMENT_REGISTERS(0)
 778
 779         add     $(14*8),%rsp
 780         ret
 781
 782
 783 /******************* function asm_initialize_thread_stack **********************
 784 *                                                                              *
 785 * initialized a thread stack                                                   *
 786 * (to)->restorePoint = asm_initialize_thread_stack((u1*)(func), (to)->stackEnd)*
 787 *                                                                              *
 788 *******************************************************************************/
 789
 790 asm_initialize_thread_stack:
 791         sub     $(7*8),%rsi
 792
 793         xor     %r10,%r10
 794         mov     %r10,0*8(%rsi)
 795         mov     %r10,1*8(%rsi)
 796         mov     %r10,2*8(%rsi)
 797         mov     %r10,3*8(%rsi)
 798         mov     %r10,4*8(%rsi)
 799         mov     %r10,5*8(%rsi)
 800
 801         mov     %rdi,6*8(%rsi)          /* save (u1*) (func)                  */
 802         mov     %rsi,%rax               /* return restorepoint in %rax        */
 803         ret
 804
 805
 806 /******************* function asm_perform_threadswitch *************************
 807 *                                                                              *
 808 *   void asm_perform_threadswitch (u1 **from, u1 **to, u1 **stackTop);         *
 809 *                                                                              *
 810 *   performs a threadswitch                                                    *
 811 *                                                                              *
 812 *******************************************************************************/
 813
 814 asm_perform_threadswitch:
 815         sub     $(7*8),%rsp             /* allocate stack frame               */
 816
 817         mov     %rbx,0*8(%rsp)
 818         mov     %rbp,1*8(%rsp)
 819         mov     %r12,2*8(%rsp)
 820         mov     %r13,3*8(%rsp)
 821         mov     %r14,4*8(%rsp)
 822         mov     %r15,5*8(%rsp)
 823
 824         mov     7*8(%rsp),%rax                  /* save current return address        */
 825         mov     %rax,6*8(%rsp)
 826
 827         mov     %rsp,(%rdi)                     /* first argument **from              */
 828         mov     %rsp,(%rdx)                     /* third argument **stackTop          */
 829
 830         mov     (%rsi),%rsp                     /* load new stack pointer             */
 831
 832         mov     0*8(%rsp),%rbx
 833         mov     1*8(%rsp),%rbp
 834         mov     2*8(%rsp),%r12
 835         mov     3*8(%rsp),%r13
 836         mov     4*8(%rsp),%r14
 837         mov     5*8(%rsp),%r15
 838
 839         mov     6*8(%rsp),%rax          /* restore return address             */
 840         add     $(7*8),%rsp             /* free stack frame                   */
 841         mov     %rax,(%rsp)
 842         ret
 843
 844
 845 /********************* function asm_switchstackandcall *************************
 846 *                                                                              *
 847 *  int asm_switchstackandcall (void *stack, void *func, void **stacktopsave,   *
 848 *                                      void *p);                                       *
 849 *                                                                              *
 850 *   Switches to a new stack, calls a function and switches back.               *
 851 *       a0 (%rdi)     new stack pointer                                        *
 852 *       a1 (%rsi)     function pointer                                         *
 853 *               a2 (%rdx)     pointer to variable where stack top should be stored     *
 854 *       a3 (%rcx)     pointer to user data, is passed to the function          *
 855 *                                                                              *
 856 *******************************************************************************/
 857
 858 asm_switchstackandcall:
 859         sub     $(1*8),%rsp             /* keep stack 16-byte aligned         */
 860         sub     $16,%rdi                                /* allocate new stack                 */
 861
 862         mov     8(%rsp),%rax                    /* save return address on new stack   */
 863         mov     %rax,(%rdi)
 864         mov     %rsp,8(%rdi)                    /* save old stack pointer on new stack*/
 865         mov     %rsp,(%rdx)                             /* save old stack pointer to variable */
 866
 867         mov     %rdi,%rsp                               /* switch to new stack                */
 868
 869         mov     %rcx,%rdi                       /* pass pointer                       */
 870         call    *%rsi                                   /* and call function                  */
 871
 872         mov     (%rsp),%r10                             /* load return address                */
 873         mov     8(%rsp),%rsp                    /* switch to old stack                */
 874         add     $(1*8),%rsp             /* free stack space                   */
 875         mov     %r10,(%rsp)             /* write return adress                */
 876         ret
 877
 878
 879 asm_getclassvalues_atomic:
 880 _crit_restart2:
 881 _crit_begin2:
 882         movl    offbaseval(a0),itmp1l
 883         movl    offdiffval(a0),itmp2l
 884         movl    offbaseval(a1),itmp3l
 885 _crit_end2:
 886         movl    itmp1l,offcast_super_baseval(a2)
 887         movl    itmp2l,offcast_super_diffval(a2)
 888         movl    itmp3l,offcast_sub_baseval(a2)
 889         ret
 890
 891         .data
 892
 893 asm_criticalsections:
 894 #if defined(USE_THREADS) && defined(NATIVE_THREADS)
 895 #if 0
 896         .quad   _crit_begin1
 897         .quad   _crit_end1
 898         .quad   _crit_restart1
 899 #endif
 900         .quad   _crit_begin2
 901         .quad   _crit_end2
 902         .quad   _crit_restart2
 903 #endif
 904         .quad 0
 905
 906
 907 /*
 908  * These are local overrides for various environment variables in Emacs.
 909  * Please do not remove this and leave it at the end of the file, where
 910  * Emacs will automagically detect them.
 911  * ---------------------------------------------------------------------
 912  * Local variables:
 913  * mode: asm
 914  * indent-tabs-mode: t
 915  * c-basic-offset: 4
 916  * tab-width: 4
 917  * End:
 918  */