src/runtime/x86-assem.S

   1 /*
   2  * very-low-level utilities for runtime support
   3  */
   4
   5 /*
   6  * This software is part of the SBCL system. See the README file for
   7  * more information.
   8  *
   9  * This software is derived from the CMU CL system, which was
  10  * written at Carnegie Mellon University and released into the
  11  * public domain. The software is in the public domain and is
  12  * provided with absolutely no warranty. See the COPYING and CREDITS
  13  * files for more information.
  14  */
  15 \f
  16 #define LANGUAGE_ASSEMBLY
  17 #include "validate.h"
  18 #include "sbcl.h"
  19 #include "genesis/closure.h"
  20 #include "genesis/fdefn.h"
  21 #include "genesis/static-symbols.h"
  22 #include "genesis/symbol.h"
  23
  24
  25 /* Minimize conditionalization for different OS naming schemes. */
  26 #if defined __linux__  || defined __FreeBSD__ /* (but *not* OpenBSD) */
  27 #define GNAME(var) var
  28 #else
  29 #define GNAME(var) _##var
  30 #endif
  31
  32 /* Get the right type of alignment. Linux and FreeBSD (but not OpenBSD)
  33  * want alignment in bytes. */
  34 #if defined(__linux__) || defined(__FreeBSD__)
  35 #define align_4byte     4
  36 #define align_8byte     8
  37 #define align_16byte    16
  38 #else
  39 #define align_4byte     2
  40 #define align_8byte     3
  41 #define align_16byte    4
  42 #endif
  43
  44         .text
  45         .global GNAME(foreign_function_call_active)
  46
  47 \f
  48 /*
  49  * A call to call_into_c preserves esi, edi, and ebp.
  50  * (The C function will preserve ebx, esi, edi, and ebp across its
  51  * function call, but we trash ebx ourselves by using it to save the
  52  * return Lisp address.)
  53  *
  54  * Return values are in eax and maybe edx for quads, or st(0) for
  55  * floats.
  56  *
  57  * This should work for Lisp calls C calls Lisp calls C..
  58  */
  59         .text
  60         .align  align_16byte,0x90
  61         .global GNAME(call_into_c)
  62         .type   GNAME(call_into_c),@function
  63 GNAME(call_into_c):
  64         movl    $1,GNAME(foreign_function_call_active)
  65
  66 /* Save the return Lisp address in ebx. */
  67         popl    %ebx
  68
  69 /* Setup the NPX for C */
  70         fstp    %st(0)
  71         fstp    %st(0)
  72         fstp    %st(0)
  73         fstp    %st(0)
  74         fstp    %st(0)
  75         fstp    %st(0)
  76         fstp    %st(0)
  77         fstp    %st(0)
  78
  79         call    *%eax           # normal callout using Lisp stack
  80
  81         movl    %eax,%ecx       # remember integer return value
  82
  83 /* Check for a return FP value. */
  84         fxam
  85         fnstsw  %eax
  86         andl    $0x4500,%eax
  87         cmpl    $0x4100,%eax
  88         jne     Lfp_rtn_value
  89
  90 /* The return value is in eax, or eax,edx? */
  91 /* Set up the NPX stack for Lisp. */
  92         fldz                    # Ensure no regs are empty.
  93         fldz
  94         fldz
  95         fldz
  96         fldz
  97         fldz
  98         fldz
  99         fldz
 100
 101 /* Restore the return value. */
 102         movl    %ecx,%eax       # maybe return value
 103
 104         movl    $0,GNAME(foreign_function_call_active)
 105 /* Return. */
 106         jmp     *%ebx
 107
 108 Lfp_rtn_value:
 109 /* The return result is in st(0). */
 110 /* Set up the NPX stack for Lisp, placing the result in st(0). */
 111         fldz                    # Ensure no regs are empty.
 112         fldz
 113         fldz
 114         fldz
 115         fldz
 116         fldz
 117         fldz
 118         fxch    %st(7)          # Move the result back to st(0).
 119
 120 /* We don't need to restore eax, because the result is in st(0). */
 121
 122         movl    $0,GNAME(foreign_function_call_active)
 123 /* Return. */
 124         jmp     *%ebx
 125
 126         .size   GNAME(call_into_c), . - GNAME(call_into_c)
 127
 128 \f
 129         .text
 130         .global GNAME(call_into_lisp)
 131         .type  GNAME(call_into_lisp),@function
 132
 133 /* The C conventions require that ebx, esi, edi, and ebp be preserved
 134  * across function calls. */
 135 /* The *ALIEN-STACK* pointer is set up on the first call_into_lisp when
 136  * the stack changes. */
 137
 138         .align  align_16byte,0x90
 139 GNAME(call_into_lisp):
 140         pushl   %ebp            # Save old frame pointer.
 141         movl    %esp,%ebp       # Establish new frame.
 142
 143 /* Save the NPX state */
 144         fwait                   # Catch any pending NPX exceptions.
 145         subl    $108,%esp       # Make room for the NPX state.
 146         fnsave  (%esp)          # resets NPX
 147
 148         movl    (%esp),%eax     # Load NPX control word.
 149         andl    $0xfffff3ff,%eax        # Set rounding mode to nearest.
 150         orl     $0x00000300,%eax        # Set precision to 64 bits.
 151         pushl   %eax
 152         fldcw   (%esp)          # Recover modes.
 153         popl    %eax
 154
 155         fldz                    # Ensure no FP regs are empty.
 156         fldz
 157         fldz
 158         fldz
 159         fldz
 160         fldz
 161         fldz
 162         fldz
 163
 164 /* Save C regs: ebx esi edi. */
 165         pushl   %ebx
 166         pushl   %esi
 167         pushl   %edi
 168
 169 /* Clear descriptor regs. */
 170         xorl    %eax,%eax       # lexenv
 171         xorl    %ebx,%ebx       # available
 172         xorl    %ecx,%ecx       # arg count
 173         xorl    %edx,%edx       # first arg
 174         xorl    %edi,%edi       # second arg
 175         xorl    %esi,%esi       # third arg
 176
 177 /* no longer in function call */
 178         movl    %eax, GNAME(foreign_function_call_active)
 179
 180         movl    %esp,%ebx       # remember current stack
 181         cmpl    $CONTROL_STACK_START,%esp
 182         jbe     ChangeToLispStack
 183         cmpl    $CONTROL_STACK_END,%esp
 184         jbe     OnLispStack
 185 ChangeToLispStack:
 186         /* Setup the *alien-stack* pointer */
 187         movl    %esp,ALIEN_STACK + SYMBOL_VALUE_OFFSET
 188         movl    $CONTROL_STACK_END,%esp         # new stack
 189 OnLispStack:
 190         pushl   %ebx            # Save entry stack on (maybe) new stack.
 191
 192         /* Establish Lisp args. */
 193         movl     8(%ebp),%eax   # lexenv?
 194         movl    12(%ebp),%ebx   # address of arg vec
 195         movl    16(%ebp),%ecx   # num args
 196         shll    $2,%ecx         # Make num args into fixnum.
 197         cmpl    $0,%ecx
 198         je      Ldone
 199         movl    (%ebx),%edx     # arg0
 200         cmpl    $4,%ecx
 201         je      Ldone
 202         movl    4(%ebx),%edi    # arg1
 203         cmpl    $8,%ecx
 204         je      Ldone
 205         movl    8(%ebx),%esi    # arg2
 206 Ldone:
 207         /* Registers eax, ecx, edx, edi, and esi are now live. */
 208
 209         /* Alloc new frame. */
 210         mov     %esp,%ebx       # The current sp marks start of new frame.
 211         push    %ebp            # fp in save location S0
 212         sub     $8,%esp         # Ensure 3 slots are allocated, one above.
 213         mov     %ebx,%ebp       # Switch to new frame.
 214
 215         /* Indirect the closure. */
 216         call    *CLOSURE_FUN_OFFSET(%eax)
 217
 218         /* Multi-value return; blow off any extra values. */
 219         mov     %ebx, %esp
 220         /* single value return */
 221
 222 /* Restore the stack, in case there was a stack change. */
 223         popl    %esp            # c-sp
 224
 225 /* Restore C regs: ebx esi edi. */
 226         popl    %edi
 227         popl    %esi
 228         popl    %ebx
 229
 230 /* Restore the NPX state. */
 231         frstor  (%esp)
 232         addl    $108, %esp
 233
 234         popl    %ebp            # c-sp
 235         movl    %edx,%eax       # c-val
 236         ret
 237         .size   GNAME(call_into_lisp), . - GNAME(call_into_lisp)
 238 \f
 239 /* support for saving and restoring the NPX state from C */
 240         .text
 241         .global GNAME(fpu_save)
 242         .type   GNAME(fpu_save),@function
 243         .align  2,0x90
 244 GNAME(fpu_save):
 245         movl    4(%esp),%eax
 246         fnsave  (%eax)          # Save the NPX state. (resets NPX)
 247         ret
 248         .size   GNAME(fpu_save),.-GNAME(fpu_save)
 249
 250         .global GNAME(fpu_restore)
 251         .type   GNAME(fpu_restore),@function
 252         .align  2,0x90
 253 GNAME(fpu_restore):
 254         movl    4(%esp),%eax
 255         frstor  (%eax)          # Restore the NPX state.
 256         ret
 257         .size   GNAME(fpu_restore),.-GNAME(fpu_restore)
 258 \f
 259 /*
 260  * the undefined-function trampoline
 261  */
 262         .text
 263         .align  align_4byte,0x90
 264         .global GNAME(undefined_tramp)
 265         .type   GNAME(undefined_tramp),@function
 266 GNAME(undefined_tramp):
 267         int3
 268         .byte   trap_Error
 269         .byte   2
 270         .byte   UNDEFINED_FUN_ERROR
 271         .byte   sc_DescriptorReg # eax in the Descriptor-reg SC
 272         ret
 273         .size   GNAME(undefined_tramp), .-GNAME(undefined_tramp)
 274
 275 /*
 276  * the closure trampoline
 277  */
 278         .text
 279         .align  align_4byte,0x90
 280         .global GNAME(closure_tramp)
 281         .type   GNAME(closure_tramp),@function
 282 GNAME(closure_tramp):
 283         movl    FDEFN_FUN_OFFSET(%eax),%eax
 284         /* FIXME: The '*' after "jmp" in the next line is from PVE's
 285          * patch posted to the CMU CL mailing list Oct 6, 1999. It looks
 286          * reasonable, and it certainly seems as though if CMU CL needs it,
 287          * SBCL needs it too, but I haven't actually verified that it's
 288          * right. It would be good to find a way to force the flow of
 289          * control through here to test it. */
 290         jmp     *CLOSURE_FUN_OFFSET(%eax)
 291         .size   GNAME(closure_tramp), .-GNAME(closure_tramp)
 292
 293 /*
 294  * fun-end breakpoint magic
 295  */
 296         .text
 297         .global GNAME(fun_end_breakpoint_guts)
 298         .align  align_4byte
 299 GNAME(fun_end_breakpoint_guts):
 300         /* Multiple Value return */
 301         jmp     multiple_value_return
 302         /* Single value return: The eventual return will now use the
 303            multiple values return convention but with a return values
 304            count of one. */
 305         movl    %esp,%ebx       # Setup ebx - the ofp.
 306         subl    $4,%esp         # Allocate one stack slot for the return value
 307         movl    $4,%ecx         # Setup ecx for one return value.
 308         movl    $NIL,%edi       # default second value
 309         movl    $NIL,%esi       # default third value
 310
 311 multiple_value_return:
 312
 313         .global GNAME(fun_end_breakpoint_trap)
 314 GNAME(fun_end_breakpoint_trap):
 315         int3
 316         .byte   trap_FunEndBreakpoint
 317         hlt                     # We should never return here.
 318
 319         .global GNAME(fun_end_breakpoint_end)
 320 GNAME(fun_end_breakpoint_end):
 321
 322 \f
 323         .global GNAME(do_pending_interrupt)
 324         .type   GNAME(do_pending_interrupt),@function
 325         .align  align_4byte,0x90
 326 GNAME(do_pending_interrupt):
 327         int3
 328         .byte   trap_PendingInterrupt
 329         ret
 330         .size   GNAME(do_pending_interrupt),.-GNAME(do_pending_interrupt)
 331 \f
 332 #ifdef LISP_FEATURE_GENCGC
 333 /* This is a fast bzero using the FPU. The first argument is the start
 334  * address which needs to be aligned on an 8 byte boundary, the second
 335  * argument is the number of bytes, which must be a nonzero multiple
 336  * of 8 bytes. */
 337 /* FIXME whether this is still faster than using the OS's bzero or
 338  * equivalent, we don't know */
 339         .text
 340         .globl  GNAME(i586_bzero)
 341         .type   GNAME(i586_bzero),@function
 342         .align  align_4byte,0x90
 343 GNAME(i586_bzero):
 344         movl    4(%esp),%edx    # Load the start address.
 345         movl    8(%esp),%eax    # Load the number of bytes.
 346         fldz
 347 l1:     fstl    0(%edx)
 348         addl    $8,%edx
 349         subl    $8,%eax
 350         jnz     l1
 351         fstp    %st(0)
 352         ret
 353         .size   GNAME(i586_bzero),.-GNAME(i586_bzero)
 354 #endif
 355 \f
 356
 357 /*
 358  * Allocate bytes and return the start of the allocated space
 359  * in the specified destination register.
 360  *
 361  * In the general case the size will be in the destination register.
 362  *
 363  * All registers must be preserved except the destination.
 364  * The C conventions will preserve ebx, esi, edi, and ebp.
 365  * So only eax, ecx, and edx need special care here.
 366  */
 367
 368         .globl  GNAME(alloc_to_eax)
 369         .type   GNAME(alloc_to_eax),@function
 370         .align  align_4byte,0x90
 371 GNAME(alloc_to_eax):
 372         pushl   %ecx    # Save ecx and edx as C could destroy them.
 373         pushl   %edx
 374         pushl   %eax    # Push the size.
 375         call    GNAME(alloc)
 376         addl    $4,%esp # Pop the size arg.
 377         popl    %edx    # Restore ecx and edx.
 378         popl    %ecx
 379         ret
 380         .size   GNAME(alloc_to_eax),.-GNAME(alloc_to_eax)
 381
 382         .globl  GNAME(alloc_8_to_eax)
 383         .type   GNAME(alloc_8_to_eax),@function
 384         .align  align_4byte,0x90
 385 GNAME(alloc_8_to_eax):
 386         pushl   %ecx    # Save ecx and edx as C could destroy them.
 387         pushl   %edx
 388         pushl   $8      # Push the size.
 389         call    GNAME(alloc)
 390         addl    $4,%esp # Pop the size arg.
 391         popl    %edx    # Restore ecx and edx.
 392         popl    %ecx
 393         ret
 394         .size   GNAME(alloc_8_to_eax),.-GNAME(alloc_8_to_eax)
 395
 396         .globl  GNAME(alloc_8_to_eax)
 397         .type   GNAME(alloc_8_to_eax),@function
 398         .align  align_4byte,0x90
 399
 400         .globl  GNAME(alloc_16_to_eax)
 401         .type   GNAME(alloc_16_to_eax),@function
 402         .align  align_4byte,0x90
 403 GNAME(alloc_16_to_eax):
 404         pushl   %ecx    # Save ecx and edx as C could destroy them.
 405         pushl   %edx
 406         pushl   $16     # Push the size.
 407         call    GNAME(alloc)
 408         addl    $4,%esp # Pop the size arg.
 409         popl    %edx    # Restore ecx and edx.
 410         popl    %ecx
 411         ret
 412         .size   GNAME(alloc_16_to_eax),.-GNAME(alloc_16_to_eax)
 413
 414         .globl  GNAME(alloc_to_ecx)
 415         .type   GNAME(alloc_to_ecx),@function
 416         .align  align_4byte,0x90
 417 GNAME(alloc_to_ecx):
 418         pushl   %eax    # Save eax and edx as C could destroy them.
 419         pushl   %edx
 420         pushl   %ecx    # Push the size.
 421         call    GNAME(alloc)
 422         addl    $4,%esp # Pop the size arg.
 423         movl    %eax,%ecx       # Set up the destination.
 424         popl    %edx    # Restore eax and edx.
 425         popl    %eax
 426         ret
 427         .size   GNAME(alloc_to_ecx),.-GNAME(alloc_to_ecx)
 428
 429         .globl  GNAME(alloc_8_to_ecx)
 430         .type   GNAME(alloc_8_to_ecx),@function
 431         .align  align_4byte,0x90
 432 GNAME(alloc_8_to_ecx):
 433         pushl   %eax    # Save eax and edx as C could destroy them.
 434         pushl   %edx
 435         pushl   $8      # Push the size.
 436         call    GNAME(alloc)
 437         addl    $4,%esp # Pop the size arg.
 438         movl    %eax,%ecx       # Set up the destination.
 439         popl    %edx    # Restore eax and edx.
 440         popl    %eax
 441         ret
 442         .size   GNAME(alloc_8_to_ecx),.-GNAME(alloc_8_to_ecx)
 443
 444         .globl  GNAME(alloc_16_to_ecx)
 445         .type   GNAME(alloc_16_to_ecx),@function
 446         .align  align_4byte,0x90
 447 GNAME(alloc_16_to_ecx):
 448         pushl   %eax    # Save eax and edx as C could destroy them.
 449         pushl   %edx
 450         pushl   $16     # Push the size.
 451         call    GNAME(alloc)
 452         addl    $4,%esp # Pop the size arg.
 453         movl    %eax,%ecx       # Set up the destination.
 454         popl    %edx    # Restore eax and edx.
 455         popl    %eax
 456         ret
 457         .size   GNAME(alloc_16_to_ecx),.-GNAME(alloc_16_to_ecx)
 458
 459
 460         .globl  GNAME(alloc_to_edx)
 461         .type   GNAME(alloc_to_edx),@function
 462         .align  align_4byte,0x90
 463 GNAME(alloc_to_edx):
 464         pushl   %eax    # Save eax and ecx as C could destroy them.
 465         pushl   %ecx
 466         pushl   %edx    # Push the size.
 467         call    GNAME(alloc)
 468         addl    $4,%esp # Pop the size arg.
 469         movl    %eax,%edx       # Set up the destination.
 470         popl    %ecx    # Restore eax and ecx.
 471         popl    %eax
 472         ret
 473         .size   GNAME(alloc_to_edx),.-GNAME(alloc_to_edx)
 474
 475         .globl  GNAME(alloc_8_to_edx)
 476         .type   GNAME(alloc_8_to_edx),@function
 477         .align  align_4byte,0x90
 478 GNAME(alloc_8_to_edx):
 479         pushl   %eax    # Save eax and ecx as C could destroy them.
 480         pushl   %ecx
 481         pushl   $8      # Push the size.
 482         call    GNAME(alloc)
 483         addl    $4,%esp # Pop the size arg.
 484         movl    %eax,%edx       # Set up the destination.
 485         popl    %ecx    # Restore eax and ecx.
 486         popl    %eax
 487         ret
 488         .size   GNAME(alloc_8_to_edx),.-GNAME(alloc_8_to_edx)
 489
 490         .globl  GNAME(alloc_16_to_edx)
 491         .type   GNAME(alloc_16_to_edx),@function
 492         .align  align_4byte,0x90
 493 GNAME(alloc_16_to_edx):
 494         pushl   %eax    # Save eax and ecx as C could destroy them.
 495         pushl   %ecx
 496         pushl   $16     # Push the size.
 497         call    GNAME(alloc)
 498         addl    $4,%esp # Pop the size arg.
 499         movl    %eax,%edx       # Set up the destination.
 500         popl    %ecx    # Restore eax and ecx.
 501         popl    %eax
 502         ret
 503         .size   GNAME(alloc_16_to_edx),.-GNAME(alloc_16_to_edx)
 504
 505
 506
 507         .globl  GNAME(alloc_to_ebx)
 508         .type   GNAME(alloc_to_ebx),@function
 509         .align  align_4byte,0x90
 510 GNAME(alloc_to_ebx):
 511         pushl   %eax    # Save eax, ecx, and edx as C could destroy them.
 512         pushl   %ecx
 513         pushl   %edx
 514         pushl   %ebx    # Push the size.
 515         call    GNAME(alloc)
 516         addl    $4,%esp # Pop the size arg.
 517         movl    %eax,%ebx       # Set up the destination.
 518         popl    %edx    # Restore eax, ecx and edx.
 519         popl    %ecx
 520         popl    %eax
 521         ret
 522         .size   GNAME(alloc_to_ebx),.-GNAME(alloc_to_ebx)
 523
 524         .globl  GNAME(alloc_8_to_ebx)
 525         .type   GNAME(alloc_8_to_ebx),@function
 526         .align  align_4byte,0x90
 527 GNAME(alloc_8_to_ebx):
 528         pushl   %eax    # Save eax, ecx, and edx as C could destroy them.
 529         pushl   %ecx
 530         pushl   %edx
 531         pushl   $8      # Push the size.
 532         call    GNAME(alloc)
 533         addl    $4,%esp # Pop the size arg.
 534         movl    %eax,%ebx       # Set up the destination.
 535         popl    %edx    # Restore eax, ecx and edx.
 536         popl    %ecx
 537         popl    %eax
 538         ret
 539         .size   GNAME(alloc_8_to_ebx),.-GNAME(alloc_8_to_ebx)
 540
 541         .globl  GNAME(alloc_16_to_ebx)
 542         .type   GNAME(alloc_16_to_ebx),@function
 543         .align  align_4byte,0x90
 544 GNAME(alloc_16_to_ebx):
 545         pushl   %eax    # Save eax, ecx, and edx as C could destroy them.
 546         pushl   %ecx
 547         pushl   %edx
 548         pushl   $16     # Push the size
 549         call    GNAME(alloc)
 550         addl    $4,%esp # pop the size arg.
 551         movl    %eax,%ebx       # setup the destination.
 552         popl    %edx    # Restore eax, ecx and edx.
 553         popl    %ecx
 554         popl    %eax
 555         ret
 556         .size   GNAME(alloc_16_to_ebx),.-GNAME(alloc_16_to_ebx)
 557
 558
 559
 560         .globl  GNAME(alloc_to_esi)
 561         .type   GNAME(alloc_to_esi),@function
 562         .align  align_4byte,0x90
 563 GNAME(alloc_to_esi):
 564         pushl   %eax    # Save eax, ecx, and edx as C could destroy them.
 565         pushl   %ecx
 566         pushl   %edx
 567         pushl   %esi    # Push the size
 568         call    GNAME(alloc)
 569         addl    $4,%esp # pop the size arg.
 570         movl    %eax,%esi       # setup the destination.
 571         popl    %edx    # Restore eax, ecx and edx.
 572         popl    %ecx
 573         popl    %eax
 574         ret
 575         .size   GNAME(alloc_to_esi),.-GNAME(alloc_to_esi)
 576
 577         .globl  GNAME(alloc_8_to_esi)
 578         .type   GNAME(alloc_8_to_esi),@function
 579         .align  align_4byte,0x90
 580 GNAME(alloc_8_to_esi):
 581         pushl   %eax    # Save eax, ecx, and edx as C could destroy them.
 582         pushl   %ecx
 583         pushl   %edx
 584         pushl   $8      # Push the size
 585         call    GNAME(alloc)
 586         addl    $4,%esp # pop the size arg.
 587         movl    %eax,%esi       # setup the destination.
 588         popl    %edx    # Restore eax, ecx and edx.
 589         popl    %ecx
 590         popl    %eax
 591         ret
 592         .size   GNAME(alloc_8_to_esi),.-GNAME(alloc_8_to_esi)
 593
 594         .globl  GNAME(alloc_16_to_esi)
 595         .type   GNAME(alloc_16_to_esi),@function
 596         .align  align_4byte,0x90
 597 GNAME(alloc_16_to_esi):
 598         pushl   %eax    # Save eax, ecx, and edx as C could destroy them.
 599         pushl   %ecx
 600         pushl   %edx
 601         pushl   $16     # Push the size
 602         call    GNAME(alloc)
 603         addl    $4,%esp # pop the size arg.
 604         movl    %eax,%esi       # setup the destination.
 605         popl    %edx    # Restore eax, ecx and edx.
 606         popl    %ecx
 607         popl    %eax
 608         ret
 609         .size   GNAME(alloc_16_to_esi),.-GNAME(alloc_16_to_esi)
 610
 611
 612         .globl  GNAME(alloc_to_edi)
 613         .type   GNAME(alloc_to_edi),@function
 614         .align  align_4byte,0x90
 615 GNAME(alloc_to_edi):
 616         pushl   %eax    # Save eax, ecx, and edx as C could destroy them.
 617         pushl   %ecx
 618         pushl   %edx
 619         pushl   %edi    # Push the size
 620         call    GNAME(alloc)
 621         addl    $4,%esp # pop the size arg.
 622         movl    %eax,%edi       # setup the destination.
 623         popl    %edx    # Restore eax, ecx and edx.
 624         popl    %ecx
 625         popl    %eax
 626         ret
 627         .size   GNAME(alloc_to_edi),.-GNAME(alloc_to_edi)
 628
 629         .globl  GNAME(alloc_8_to_edi)
 630         .type   GNAME(alloc_8_to_edi),@function
 631         .align  align_4byte,0x90
 632 GNAME(alloc_8_to_edi):
 633         pushl   %eax    # Save eax, ecx, and edx as C could destroy them.
 634         pushl   %ecx
 635         pushl   %edx
 636         pushl   $8      # Push the size
 637         call    GNAME(alloc)
 638         addl    $4,%esp # pop the size arg.
 639         movl    %eax,%edi       # setup the destination.
 640         popl    %edx    # Restore eax, ecx and edx.
 641         popl    %ecx
 642         popl    %eax
 643         ret
 644         .size   GNAME(alloc_8_to_edi),.-GNAME(alloc_8_to_edi)
 645
 646         .globl  GNAME(alloc_16_to_edi)
 647         .type   GNAME(alloc_16_to_edi),@function
 648         .align  align_4byte,0x90
 649 GNAME(alloc_16_to_edi):
 650         pushl   %eax    # Save eax, ecx, and edx as C could destroy them.
 651         pushl   %ecx
 652         pushl   %edx
 653         pushl   $16     # Push the size
 654         call    GNAME(alloc)
 655         addl    $4,%esp # pop the size arg.
 656         movl    %eax,%edi       # setup the destination.
 657         popl    %edx    # Restore eax, ecx and edx.
 658         popl    %ecx
 659         popl    %eax
 660         ret
 661         .size   GNAME(alloc_16_to_edi),.-GNAME(alloc_16_to_edi)
 662
 663
 664 \f
 665 #ifdef LISP_FEATURE_GENCGC_INLINE_ALLOC /* disabled at present */
 666
 667 /* These routines are called from Lisp when an inline allocation
 668  * overflows. Every register except the result needs to be preserved.
 669  * We depend on C to preserve ebx, esi, edi, and ebp.
 670  * But where necessary must save eax, ecx, edx. */
 671
 672 /* This routine handles an overflow with eax=crfp+size. So the
 673  * size=eax-crfp. */
 674         .align  align_4byte
 675         .globl  GNAME(alloc_overflow_eax)
 676         .type   GNAME(alloc_overflow_eax),@function
 677 GNAME(alloc_overflow_eax):
 678         pushl   %ecx            # Save ecx
 679         pushl   %edx            # Save edx
 680         /* Calculate the size for the allocation. */
 681         subl    GNAME(current_region_free_pointer),%eax
 682         pushl   %eax            # Push the size
 683         call    GNAME(alloc)
 684         addl    $4,%esp # pop the size arg.
 685         popl    %edx    # Restore edx.
 686         popl    %ecx    # Restore ecx.
 687         addl    $6,(%esp) # Adjust the return address to skip the next inst.
 688         ret
 689         .size    GNAME(alloc_overflow_eax),.-GNAME(alloc_overflow_eax)
 690
 691 /* This routine handles an overflow with ecx=crfp+size. So the
 692  * size=ecx-crfp. */
 693         .align  align_4byte
 694         .globl  GNAME(alloc_overflow_ecx)
 695         .type   GNAME(alloc_overflow_ecx),@function
 696 GNAME(alloc_overflow_ecx):
 697         pushl   %eax            # Save eax
 698         pushl   %edx            # Save edx
 699         /* Calculate the size for the allocation. */
 700         subl    GNAME(current_region_free_pointer),%ecx
 701         pushl   %ecx            # Push the size
 702         call    GNAME(alloc)
 703         addl    $4,%esp # pop the size arg.
 704         movl    %eax,%ecx       # setup the destination.
 705         popl    %edx    # Restore edx.
 706         popl    %eax    # Restore eax.
 707         addl    $6,(%esp) # Adjust the return address to skip the next inst.
 708         ret
 709         .size    GNAME(alloc_overflow_ecx),.-GNAME(alloc_overflow_ecx)
 710
 711 /* This routine handles an overflow with edx=crfp+size. So the
 712  * size=edx-crfp. */
 713         .align  align_4byte
 714         .globl  GNAME(alloc_overflow_edx)
 715         .type   GNAME(alloc_overflow_edx),@function
 716 GNAME(alloc_overflow_edx):
 717         pushl   %eax            # Save eax
 718         pushl   %ecx            # Save ecx
 719         /* Calculate the size for the allocation. */
 720         subl    GNAME(current_region_free_pointer),%edx
 721         pushl   %edx            # Push the size
 722         call    GNAME(alloc)
 723         addl    $4,%esp # pop the size arg.
 724         movl    %eax,%edx       # setup the destination.
 725         popl    %ecx    # Restore ecx.
 726         popl    %eax    # Restore eax.
 727         addl    $6,(%esp) # Adjust the return address to skip the next inst.
 728         ret
 729         .size    GNAME(alloc_overflow_edx),.-GNAME(alloc_overflow_edx)
 730
 731 /* This routine handles an overflow with ebx=crfp+size. So the
 732  * size=ebx-crfp. */
 733         .align  align_4byte
 734         .globl  GNAME(alloc_overflow_ebx)
 735         .type   GNAME(alloc_overflow_ebx),@function
 736 GNAME(alloc_overflow_ebx):
 737         pushl   %eax            # Save eax
 738         pushl   %ecx            # Save ecx
 739         pushl   %edx            # Save edx
 740         /* Calculate the size for the allocation. */
 741         subl    GNAME(current_region_free_pointer),%ebx
 742         pushl   %ebx            # Push the size
 743         call    GNAME(alloc)
 744         addl    $4,%esp # pop the size arg.
 745         movl    %eax,%ebx       # setup the destination.
 746         popl    %edx    # Restore edx.
 747         popl    %ecx    # Restore ecx.
 748         popl    %eax    # Restore eax.
 749         addl    $6,(%esp) # Adjust the return address to skip the next inst.
 750         ret
 751         .size    GNAME(alloc_overflow_ebx),.-GNAME(alloc_overflow_ebx)
 752
 753 /* This routine handles an overflow with esi=crfp+size. So the
 754  * size=esi-crfp. */
 755         .align  align_4byte
 756         .globl  GNAME(alloc_overflow_esi)
 757         .type   GNAME(alloc_overflow_esi),@function
 758 GNAME(alloc_overflow_esi):
 759         pushl   %eax            # Save eax
 760         pushl   %ecx            # Save ecx
 761         pushl   %edx            # Save edx
 762         /* Calculate the size for the allocation. */
 763         subl    GNAME(current_region_free_pointer),%esi
 764         pushl   %esi            # Push the size
 765         call    GNAME(alloc)
 766         addl    $4,%esp # pop the size arg.
 767         movl    %eax,%esi       # setup the destination.
 768         popl    %edx    # Restore edx.
 769         popl    %ecx    # Restore ecx.
 770         popl    %eax    # Restore eax.
 771         addl    $6,(%esp) # Adjust the return address to skip the next inst.
 772         ret
 773         .size    GNAME(alloc_overflow_esi),.-GNAME(alloc_overflow_esi)
 774
 775 /* This routine handles an overflow with edi=crfp+size. So the
 776  * size=edi-crfp. */
 777         .align  align_4byte
 778         .globl  GNAME(alloc_overflow_edi)
 779         .type   GNAME(alloc_overflow_edi),@function
 780 GNAME(alloc_overflow_edi):
 781         pushl   %eax            # Save eax
 782         pushl   %ecx            # Save ecx
 783         pushl   %edx            # Save edx
 784         /* Calculate the size for the allocation. */
 785         subl    GNAME(current_region_free_pointer),%edi
 786         pushl   %edi            # Push the size
 787         call    GNAME(alloc)
 788         addl    $4,%esp # pop the size arg.
 789         movl    %eax,%edi       # setup the destination.
 790         popl    %edx    # Restore edx.
 791         popl    %ecx    # Restore ecx.
 792         popl    %eax    # Restore eax.
 793         addl    $6,(%esp) # Adjust the return address to skip the next inst.
 794         ret
 795         .size    GNAME(alloc_overflow_edi),.-GNAME(alloc_overflow_edi)
 796
 797 #endif
 798
 799         .end