Subversion Repositories openrisc_me

#
#  Setjmp/longjmp for MeP
#
#  DJ Delorie, Red Hat Inc.
#
#  19 32-bit words in the jmpbuf:
#    $0
#    $1
#    ...
#    $15
#    $pc
#    $hi
#    $lo
#
#  Note that $0 is saved but not restored.  It can't be restored
#  as it's the return value of setjmp, but we save it in case
#  some application wants to see it in the jmp_buf.  Ideally,
#  we should not need to save anything that is call-clobbered,
#  but you never know what the user is going to tell gcc with -f
#  options.

        .noregerr
        .text

        .globl  setjmp
        .type   setjmp,@function

setjmp:

        # $1 is the address of the buffer.  We return 0 in $0.

        sw      $0, ($1)
        sw      $1, 4($1)
        sw      $2, 8($1)
        sw      $3, 12($1)
        sw      $4, 16($1)
        sw      $5, 20($1)
        sw      $6, 24($1)
        sw      $7, 28($1)
        sw      $8, 32($1)
        sw      $9, 36($1)
        sw      $10, 40($1)
        sw      $11, 44($1)
        sw      $12, 48($1)
        sw      $13, 52($1)
        sw      $14, 56($1)
        sw      $15, 60($1)

        ldc     $0, $lp
        sw      $0, 64($1)
        ldc     $0, $opt
        sra     $0, 24
        and3    $0, $0, 3
        beqz    $0, sj_skip_hilo
        ldc     $0, $hi
        sw      $0, 68($1)
        ldc     $0, $lo
        sw      $0, 72($1)
sj_skip_hilo:

        mov     $0, 0
        ret

        .globl  longjmp
        .type   longjmp,@function

longjmp:

        # $1 is the address of the buffer.  $2 is the value setjmp
        # returns.  We do not faithfully restore $0 or $lp, because
        # the act of calling setjmp clobbered those anyway.

        bnez    $2, rv_not_zero
        mov     $2, 1
rv_not_zero:

        # We restore $sp first so we can save the return value there,
        # otherwise we'd need to have another unrestored register.
        lw      $15, 60($1)
        add3    $sp, $sp, -4
        sw      $2, ($sp)

        # Now restore the general registers.
        lw      $2, 8($1)
        lw      $3, 12($1)
        lw      $4, 16($1)
        lw      $5, 20($1)
        lw      $6, 24($1)
        lw      $7, 28($1)
        lw      $8, 32($1)
        lw      $9, 36($1)
        lw      $10, 40($1)
        lw      $11, 44($1)
        lw      $12, 48($1)
        lw      $13, 52($1)
        lw      $14, 56($1)

        # We restore $pc's value to $lp so that we can just ret later.
        lw      $0, 64($1)
        stc     $0, $lp
        ldc     $0, $opt
        sra     $0, 24
        and3    $0, $0, 3
        beqz    $0, lj_skip_hilo
        lw      $0, 68($1)
        stc     $0, $hi
        lw      $0, 72($1)
        stc     $0, $lo
lj_skip_hilo:

        # Restore $1
        lw      $1, 8($1)

        # Get the return value off the stack, and restore the stack.
        lw      $0, ($sp)
        add3    $sp, $sp, 4

        ret