src/runtime/hppa-assem.S

   1 #define LANGUAGE_ASSEMBLY
   2
   3 #include "sbcl.h"
   4 #include "lispregs.h"
   5 #include "genesis/closure.h"
   6 #include "genesis/fdefn.h"
   7 #include "genesis/simple-fun.h"
   8 #include "genesis/return-pc.h"
   9 #include "genesis/static-symbols.h"
  10 #include "genesis/funcallable-instance.h"
  11
  12         .level  2.0
  13         .text
  14
  15         .import $global$,data
  16         .import $$dyncall,MILLICODE
  17         .import foreign_function_call_active,data
  18         .import current_control_stack_pointer,data
  19         .import current_control_frame_pointer,data
  20         .import current_binding_stack_pointer,data
  21         .import dynamic_space_free_pointer,data
  22 /*      .import return_from_lisp_function,data */
  23
  24 \f
  25 /*
  26  * Call-into-lisp
  27  */
  28
  29         .export call_into_lisp
  30 call_into_lisp:
  31         .proc
  32         .callinfo entry_gr=18,save_rp
  33         .entry
  34         /* %arg0=function, %arg1=cfp, %arg2=nargs */
  35
  36         stw     %rp,-0x14(%sr0,%sp)
  37         stwm    %r3,0x40(%sr0,%sp)
  38         stw     %r4,-0x3c(%sr0,%sp)
  39         stw     %r5,-0x38(%sr0,%sp)
  40         stw     %r6,-0x34(%sr0,%sp)
  41         stw     %r7,-0x30(%sr0,%sp)
  42         stw     %r8,-0x2c(%sr0,%sp)
  43         stw     %r9,-0x28(%sr0,%sp)
  44         stw     %r10,-0x24(%sr0,%sp)
  45         stw     %r11,-0x20(%sr0,%sp)
  46         stw     %r12,-0x1c(%sr0,%sp)
  47         stw     %r13,-0x18(%sr0,%sp)
  48         stw     %r14,-0x14(%sr0,%sp)
  49         stw     %r15,-0x10(%sr0,%sp)
  50         stw     %r16,-0xc(%sr0,%sp)
  51         stw     %r17,-0x8(%sr0,%sp)
  52         stw     %r18,-0x4(%sr0,%sp)
  53
  54         /* Clear the descriptor regs, moving in args as approporate. */
  55         copy    %r0,reg_CODE
  56         copy    %r0,reg_FDEFN
  57         copy    %arg0,reg_LEXENV
  58         zdep    %arg2,29,30,reg_NARGS
  59         copy    %r0,reg_OCFP
  60         copy    %r0,reg_LRA
  61         copy    %r0,reg_A0
  62         copy    %r0,reg_A1
  63         copy    %r0,reg_A2
  64         copy    %r0,reg_A3
  65         copy    %r0,reg_A4
  66         copy    %r0,reg_A5
  67         copy    %r0,reg_L0
  68         copy    %r0,reg_L1
  69         copy    %r0,reg_L2
  70
  71         /* Establish NIL. */
  72         ldil    L%NIL,reg_NULL
  73         ldo     R%NIL(reg_NULL),reg_NULL
  74
  75         /* Turn on pseudo-atomic. */
  76         ldo     4(%r0),reg_ALLOC
  77
  78         /* No longer in foreign function call land. */
  79         addil   L%foreign_function_call_active-$global$,%dp
  80         stw     %r0,R%foreign_function_call_active-$global$(0,%r1)
  81
  82         /* Load lisp state. */
  83         addil   L%dynamic_space_free_pointer-$global$,%dp
  84         ldw     R%dynamic_space_free_pointer-$global$(0,%r1),%r1
  85         add     reg_ALLOC,%r1,reg_ALLOC
  86         addil   L%current_binding_stack_pointer-$global$,%dp
  87         ldw     R%current_binding_stack_pointer-$global$(0,%r1),reg_BSP
  88         addil   L%current_control_stack_pointer-$global$,%dp
  89         ldw     R%current_control_stack_pointer-$global$(0,%r1),reg_CSP
  90         addil   L%current_control_frame_pointer-$global$,%dp
  91         ldw     R%current_control_frame_pointer-$global$(0,%r1),reg_OCFP
  92         copy    %arg1,reg_CFP
  93
  94         /* End of pseudo-atomic. */
  95         addit,od        -4,reg_ALLOC,reg_ALLOC
  96
  97         /* Establish lisp arguments. */
  98         ldw     0(reg_CFP),reg_A0
  99         ldw     4(reg_CFP),reg_A1
 100         ldw     8(reg_CFP),reg_A2
 101         ldw     12(reg_CFP),reg_A3
 102         ldw     16(reg_CFP),reg_A4
 103         ldw     20(reg_CFP),reg_A5
 104
 105         /* Calculate the LRA. */
 106   ldil  L%lra-RETURN_PC_RETURN_POINT_OFFSET,reg_LRA
 107   ldo R%lra-RETURN_PC_RETURN_POINT_OFFSET(reg_LRA),reg_LRA
 108
 109         /* Indirect the closure */
 110         ldw     CLOSURE_FUN_OFFSET(0,reg_LEXENV),reg_CODE
 111   addi  SIMPLE_FUN_CODE_OFFSET,reg_CODE,reg_LIP
 112
 113 #ifdef LISP_FEATURE_HPUX
 114   /*  Get the stub address, ie assembly-routine return-from-lisp */
 115   addil   L%return_from_lisp_stub-$global$,%dp
 116   ldw     R%return_from_lisp_stub-$global$(0,%r1),reg_NL0
 117   be,n  0(%sr5,reg_NL0)
 118 #else
 119   be,n  0(%sr5,reg_NL0)
 120 #endif
 121
 122         break   0,0
 123
 124         .align  8
 125 lra:
 126   nop /* a few nops because we dont know where we land */
 127   nop /* the return convention would govern this */
 128   nop
 129   nop
 130
 131         /* Copy CFP (%r4) into someplace else and restore r4. */
 132         copy    reg_CFP,reg_NL1
 133   ldw -0x3c(0,%sp),%r4
 134
 135         /* Copy the return value. */
 136         copy    reg_A0,%ret0
 137
 138         /* Turn on pseudo-atomic. */
 139         addi    4,reg_ALLOC,reg_ALLOC
 140
 141         /* Store the lisp state. */
 142         copy    reg_ALLOC,reg_NL0
 143         depi    0,31,3,reg_NL0
 144         addil   L%dynamic_space_free_pointer-$global$,%dp
 145         stw     reg_NL0,R%dynamic_space_free_pointer-$global$(0,%r1)
 146         addil   L%current_binding_stack_pointer-$global$,%dp
 147         stw     reg_BSP,R%current_binding_stack_pointer-$global$(0,%r1)
 148         addil   L%current_control_stack_pointer-$global$,%dp
 149         stw     reg_CSP,R%current_control_stack_pointer-$global$(0,%r1)
 150         addil   L%current_control_frame_pointer-$global$,%dp
 151         stw     reg_NL1,R%current_control_frame_pointer-$global$(0,%r1)
 152
 153         /* Back in C land.  [CSP is just a handy non-zero value.] */
 154         addil   L%foreign_function_call_active-$global$,%dp
 155         stw     reg_CSP,R%foreign_function_call_active-$global$(0,%r1)
 156
 157         /* Turn off pseudo-atomic and check for traps. */
 158         addit,od        -4,reg_ALLOC,reg_ALLOC
 159
 160         ldw     -0x54(%sr0,%sp),%rp
 161         ldw     -0x4(%sr0,%sp),%r18
 162         ldw     -0x8(%sr0,%sp),%r17
 163         ldw     -0xc(%sr0,%sp),%r16
 164         ldw     -0x10(%sr0,%sp),%r15
 165         ldw     -0x14(%sr0,%sp),%r14
 166         ldw     -0x18(%sr0,%sp),%r13
 167         ldw     -0x1c(%sr0,%sp),%r12
 168         ldw     -0x20(%sr0,%sp),%r11
 169         ldw     -0x24(%sr0,%sp),%r10
 170         ldw     -0x28(%sr0,%sp),%r9
 171         ldw     -0x2c(%sr0,%sp),%r8
 172         ldw     -0x30(%sr0,%sp),%r7
 173         ldw     -0x34(%sr0,%sp),%r6
 174         ldw     -0x38(%sr0,%sp),%r5
 175         ldw     -0x3c(%sr0,%sp),%r4
 176         bv      %r0(%rp)
 177         ldwm    -0x40(%sr0,%sp),%r3
 178
 179         /* And thats all. */
 180         .exit
 181         .procend
 182
 183 \f
 184 /*
 185  * Call-into-C
 186  */
 187
 188         .export call_into_c
 189 call_into_c:
 190         /* Set up a lisp stack frame. */
 191         copy    reg_CFP, reg_OCFP
 192         copy    reg_CSP, reg_CFP
 193         addi    32, reg_CSP, reg_CSP
 194         stw     reg_OCFP, 0(0,reg_CFP) ; save old cfp
 195         stw     reg_CFP, 4(0,reg_CFP)  ; save old csp
 196         /* convert raw return PC into a fixnum PC-offset, because we dont
 197            have ahold of an lra object */
 198         sub     reg_LIP, reg_CODE, reg_NL5
 199         addi    3-OTHER_POINTER_LOWTAG, reg_NL5, reg_NL5
 200         stw     reg_NL5, 8(0,reg_CFP)
 201         stw     reg_CODE, 0xc(0,reg_CFP)
 202
 203         /* set pseudo-atomic flag */
 204         addi    4, reg_ALLOC, reg_ALLOC
 205
 206         /* Store the lisp state. */
 207         copy    reg_ALLOC,reg_NL5
 208         depi    0,31,3,reg_NL5
 209         addil   L%dynamic_space_free_pointer-$global$,%dp
 210         stw     reg_NL5,R%dynamic_space_free_pointer-$global$(0,%r1)
 211         addil   L%current_binding_stack_pointer-$global$,%dp
 212         stw     reg_BSP,R%current_binding_stack_pointer-$global$(0,%r1)
 213         addil   L%current_control_stack_pointer-$global$,%dp
 214         stw     reg_CSP,R%current_control_stack_pointer-$global$(0,%r1)
 215         addil   L%current_control_frame_pointer-$global$,%dp
 216         stw     reg_CFP,R%current_control_frame_pointer-$global$(0,%r1)
 217
 218         /* Back in C land.  [CSP is just a handy non-zero value.] */
 219         addil   L%foreign_function_call_active-$global$,%dp
 220         stw     reg_CSP,R%foreign_function_call_active-$global$(0,%r1)
 221
 222         /* Turn off pseudo-atomic and check for traps. */
 223         addit,od        -4,reg_ALLOC,reg_ALLOC
 224
 225         /* in order to be able to call incrementally linked (ld -A) functions,
 226            we have to do some mild trickery here */
 227         copy reg_CFUNC, %r22
 228         bl      $$dyncall,%r31
 229         copy    %r31, %r2
 230 call_into_c_return:
 231         /* Clear the callee saves descriptor regs. */
 232         copy    %r0, reg_A5
 233         copy    %r0, reg_L0
 234         copy    %r0, reg_L1
 235         copy    %r0, reg_L2
 236
 237         /* Turn on pseudo-atomic. */
 238         ldi     4, reg_ALLOC
 239
 240         /* Turn off foreign function call. */
 241         addil   L%foreign_function_call_active-$global$,%dp
 242         stw     %r0,R%foreign_function_call_active-$global$(0,%r1)
 243
 244         /* Load ALLOC. */
 245         addil   L%dynamic_space_free_pointer-$global$,%dp
 246         ldw     R%dynamic_space_free_pointer-$global$(0,%r1),%r1
 247         add     reg_ALLOC,%r1,reg_ALLOC
 248
 249         /* We don't need to load OCFP, CFP, CSP, or BSP because they are
 250          * in caller saves registers.
 251          */
 252
 253         /* End of pseudo-atomic. */
 254         addit,od        -4,reg_ALLOC,reg_ALLOC
 255
 256         /* Restore CODE.  Even though it is in a callee saves register
 257          * it might have been GC'ed.
 258          */
 259         ldw     0xc(0,reg_CFP), reg_CODE
 260
 261         /* Restore the return pc. */
 262         ldw     8(0,reg_CFP), reg_NL0
 263         addi    OTHER_POINTER_LOWTAG-3, reg_NL0, reg_NL0
 264 /*
 265         addi    -3, reg_NL0, reg_NL0
 266         ldi OTHER_POINTER_LOWTAG, reg_NL1
 267         sub     reg_NL0, reg_NL1, reg_NL0
 268 */
 269         add     reg_CODE, reg_NL0, reg_LIP
 270
 271         /* Pop the lisp stack frame, and back we go. */
 272         ldw     4(0,reg_CFP), reg_CSP
 273         ldw     0(0,reg_CFP), reg_OCFP
 274         copy    reg_OCFP, reg_CFP
 275         be      0(5,reg_LIP)
 276         nop
 277
 278 \f
 279 /*
 280  * Stuff to sanctify a block of memory for execution.
 281  * FIX why does this code work: parisc2.0 guide tells
 282  * us that we should add an sync after fdc and fic and
 283  * then let seven nops be executed before executing the
 284  * sanctified code.
 285  */
 286
 287
 288         .EXPORT sanctify_for_execution
 289 sanctify_for_execution:
 290         .proc
 291         .callinfo
 292         .entry
 293         /* %arg0=start addr, %arg1=length in bytes */
 294         add     %arg0,%arg1,%arg1
 295         ldo     -1(%arg1),%arg1
 296         depi    0,31,5,%arg0
 297         depi    0,31,5,%arg1
 298         ldsid   (%arg0),%r1
 299         mtsp    %r1,%sr1
 300         ldi     32,%r1                  ; bytes per cache line
 301 sanctify_loop:
 302         fdc     0(%sr1,%arg0)
 303         comb,<  %arg0,%arg1,sanctify_loop
 304         fic,m   %r1(%sr1,%arg0)
 305
 306         bv      %r0(%rp)
 307         nop
 308
 309         .exit
 310         .procend
 311
 312 \f
 313 /*
 314  * Core saving/restoring support
 315  */
 316
 317         .export call_on_stack
 318 call_on_stack:
 319         /* %arg0 = fn to invoke, %arg1 = new stack base */
 320
 321         /* Compute the new stack pointer. */
 322         addi    64,%arg1,%sp
 323
 324         /* Zero out the previous stack pointer. */
 325         stw     %r0,-4(0,%sp)
 326
 327         /* Invoke the function. */
 328         ble     0(4,%arg0)
 329         copy    %r31, %r2
 330
 331         /* Flame out. */
 332         break   0,0
 333
 334         .export save_state
 335 save_state:
 336         .proc
 337         .callinfo entry_gr=18,entry_fr=21,save_rp,calls
 338         .entry
 339
 340         stw     %rp,-0x14(%sr0,%sp)
 341         fstds,ma        %fr12,8(%sr0,%sp)
 342         fstds,ma        %fr13,8(%sr0,%sp)
 343         fstds,ma        %fr14,8(%sr0,%sp)
 344         fstds,ma        %fr15,8(%sr0,%sp)
 345         fstds,ma        %fr16,8(%sr0,%sp)
 346         fstds,ma        %fr17,8(%sr0,%sp)
 347         fstds,ma        %fr18,8(%sr0,%sp)
 348         fstds,ma        %fr19,8(%sr0,%sp)
 349         fstds,ma        %fr20,8(%sr0,%sp)
 350         fstds,ma        %fr21,8(%sr0,%sp)
 351         stwm    %r3,0x70(%sr0,%sp)
 352         stw     %r4,-0x6c(%sr0,%sp)
 353         stw     %r5,-0x68(%sr0,%sp)
 354         stw     %r6,-0x64(%sr0,%sp)
 355         stw     %r7,-0x60(%sr0,%sp)
 356         stw     %r8,-0x5c(%sr0,%sp)
 357         stw     %r9,-0x58(%sr0,%sp)
 358         stw     %r10,-0x54(%sr0,%sp)
 359         stw     %r11,-0x50(%sr0,%sp)
 360         stw     %r12,-0x4c(%sr0,%sp)
 361         stw     %r13,-0x48(%sr0,%sp)
 362         stw     %r14,-0x44(%sr0,%sp)
 363         stw     %r15,-0x40(%sr0,%sp)
 364         stw     %r16,-0x3c(%sr0,%sp)
 365         stw     %r17,-0x38(%sr0,%sp)
 366         stw     %r18,-0x34(%sr0,%sp)
 367
 368
 369         /* Remember the function we want to invoke */
 370         copy    %arg0,%r19
 371
 372         /* Pass the new stack pointer in as %arg0 */
 373         copy    %sp,%arg0
 374
 375         /* Leave %arg1 as %arg1. */
 376
 377         /* do the call. */
 378         ble     0(4,%r19)
 379         copy    %r31, %r2
 380
 381         .export _restore_state
 382 _restore_state:
 383
 384         ldw     -0xd4(%sr0,%sp),%rp
 385         ldw     -0x34(%sr0,%sp),%r18
 386         ldw     -0x38(%sr0,%sp),%r17
 387         ldw     -0x3c(%sr0,%sp),%r16
 388         ldw     -0x40(%sr0,%sp),%r15
 389         ldw     -0x44(%sr0,%sp),%r14
 390         ldw     -0x48(%sr0,%sp),%r13
 391         ldw     -0x4c(%sr0,%sp),%r12
 392         ldw     -0x50(%sr0,%sp),%r11
 393         ldw     -0x54(%sr0,%sp),%r10
 394         ldw     -0x58(%sr0,%sp),%r9
 395         ldw     -0x5c(%sr0,%sp),%r8
 396         ldw     -0x60(%sr0,%sp),%r7
 397         ldw     -0x64(%sr0,%sp),%r6
 398         ldw     -0x68(%sr0,%sp),%r5
 399         ldw     -0x6c(%sr0,%sp),%r4
 400         ldwm    -0x70(%sr0,%sp),%r3
 401         fldds,mb        -8(%sr0,%sp),%fr21
 402         fldds,mb        -8(%sr0,%sp),%fr20
 403         fldds,mb        -8(%sr0,%sp),%fr19
 404         fldds,mb        -8(%sr0,%sp),%fr18
 405         fldds,mb        -8(%sr0,%sp),%fr17
 406         fldds,mb        -8(%sr0,%sp),%fr16
 407         fldds,mb        -8(%sr0,%sp),%fr15
 408         fldds,mb        -8(%sr0,%sp),%fr14
 409         fldds,mb        -8(%sr0,%sp),%fr13
 410         bv      %r0(%rp)
 411         fldds,mb        -8(%sr0,%sp),%fr12
 412
 413
 414         .exit
 415         .procend
 416
 417         .export restore_state
 418 restore_state:
 419         .proc
 420         .callinfo
 421         copy    %arg0,%sp
 422         b       _restore_state
 423         copy    %arg1,%ret0
 424         .procend
 425
 426
 427
 428 /* FIX, add support for singlestep
 429         break   trap_SingleStepBreakpoint,0
 430         break   trap_SingleStepBreakpoint,0
 431 */
 432         .export SingleStepTraps
 433 SingleStepTraps:
 434
 435 /* Missing !! NOT
 436         there's a break 0,0 in the new version here!!!
 437 */
 438
 439 /*
 440  * For an explanation of the magic involved in function-end
 441  * breakpoints, see the implementation in ppc-assem.S.
 442  */
 443
 444         .align  8
 445         .export fun_end_breakpoint_guts
 446 fun_end_breakpoint_guts:
 447         .word   RETURN_PC_HEADER_WIDETAG + 0x800
 448         /* multiple value return point -- just jump to trap. */
 449         b,n     fun_end_breakpoint_trap
 450         /* single value return point -- convert to multiple w/ n=1 */
 451         copy    reg_CSP, reg_OCFP
 452         addi    4, reg_CSP, reg_CSP
 453         addi    4, %r0, reg_NARGS
 454         copy    reg_NULL, reg_A1
 455         copy    reg_NULL, reg_A2
 456         copy    reg_NULL, reg_A3
 457         copy    reg_NULL, reg_A4
 458         copy    reg_NULL, reg_A5
 459
 460         .export fun_end_breakpoint_trap
 461 fun_end_breakpoint_trap:
 462         break   trap_FunEndBreakpoint,0
 463         b,n     fun_end_breakpoint_trap
 464
 465         .export fun_end_breakpoint_end
 466 fun_end_breakpoint_end:
 467
 468 /* FIX-lav: these are found in assem-rtns.lisp too, but
 469    genesis.lisp has problem referencing them, so we keep
 470    these old versions too.  Lisp code cant jump to them
 471    because it is an inter space jump but lisp do intra
 472    space jumps */
 473
 474         .align  8
 475         .EXPORT closure_tramp
 476 closure_tramp:
 477         /* reg_FDEFN holds the fdefn object. */
 478         ldw     FDEFN_FUN_OFFSET(0,reg_FDEFN),reg_LEXENV
 479         ldw     CLOSURE_FUN_OFFSET(0,reg_LEXENV),reg_L0
 480         addi    SIMPLE_FUN_CODE_OFFSET, reg_L0, reg_LIP
 481         bv,n    0(reg_LIP)
 482
 483         .align  8
 484         .EXPORT undefined_tramp
 485 undefined_tramp:
 486         break   trap_Error,0
 487         .byte   4
 488         .byte   UNDEFINED_FUN_ERROR
 489         .byte   254
 490         .byte   (0x20 + sc_DescriptorReg)
 491         .byte   1
 492         .align  4
 493