Subversion Repositories openrisc_me

##=============================================================================

##

##      context.S

##

##      x86 thread context manipulation.

##

##=============================================================================

#####ECOSGPLCOPYRIGHTBEGIN####

## -------------------------------------------

## This file is part of eCos, the Embedded Configurable Operating System.

## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

##

## eCos is free software; you can redistribute it and/or modify it under

## the terms of the GNU General Public License as published by the Free

## Software Foundation; either version 2 or (at your option) any later version.

##

## eCos is distributed in the hope that it will be useful, but WITHOUT ANY

## WARRANTY; without even the implied warranty of MERCHANTABILITY or

## FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

## for more details.

##

## You should have received a copy of the GNU General Public License along

## with eCos; if not, write to the Free Software Foundation, Inc.,

## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

##

## As a special exception, if other files instantiate templates or use macros

## or inline functions from this file, or you compile this file and link it

## with other works to produce a work based on this file, this file does not

## by itself cause the resulting work to be covered by the GNU General Public

## License. However the source code for this file must still be made available

## in accordance with section (3) of the GNU General Public License.

##

## This exception does not invalidate any other reasons why a work based on

## this file might be covered by the GNU General Public License.

##

## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

## at http://sources.redhat.com/ecos/ecos-license/

## -------------------------------------------

#####ECOSGPLCOPYRIGHTEND####

##=============================================================================

#######DESCRIPTIONBEGIN####

##

## Author(s):   jskov

## Contributors:jskov, pjo, nickg, bartv

## Date:        1999-03-11

## Purpose:     CPU-specific code

## Description: This file contains the code needed to manage the

##              CPU on an i386/Linux synthetic target.

##

######DESCRIPTIONEND####

##

##=============================================================================

#include 

#------------------------------------------------------------------------------

# function declaration macro

#define FUNC_START(name)                        \

        .globl name;                            \

name:

#------------------------------------------------------------------------------

# Context switch and setjmp/longjmp support.

# Based on PowerPC context.S, using data from SYSV ABI4, i386

# supplement (page 37-38)

# http://www.sco.com/products/layered/develop/devspecs/abi386-4.pdf

#

# There is no need to worry about saving floating point context. If

# a switch occurs because of an interrupt/signal, the system will have

# saved the fpu state already before the signal handler was invoked,

# and the state will be returned when the signal handler returns i.e.

# when the interrupted thread is reactivated. If a context switch is

# voluntary, for example a call to cyg_thread_yield(), then according

# to the calling conventions all fpu registers are CALL_USED_REGISTERS

# (gcc/config/i386/i386.h) and will have been saved by the calling

# code.

#

# FIXME: it may be appropriate to match eCos thread contexts

# more closely onto Linux sigcontexts - that might facilitate

# thread-aware debugging.

# hal_thread_switch_context

# Switch thread contexts

# :     0(%esp) :     return address

# :     4(%esp) :     address of sp of next thread to execute

# :     8(%esp) :     address of sp save location of current thread

#

# %eax, %ecx, and %edx are ours to abuse.

        .extern hal_interrupts_enabled

        .extern hal_enable_interrupts

FUNC_START(hal_thread_switch_context)

        movl    4(%esp),%eax            # next context ptr

        movl    8(%esp),%edx            # this context ptr

        # Make room on the stack for the context

        movl    %esp,%ecx               # keep original SP

        sub     $i386reg_context_size,%esp

        # Save next context ptr in this context. Necessary because

        # hal_thread_load_context expects to find the ptr on the stack,

        # not in a register as on PPC.

        movl    %eax,i386reg_next_context(%esp)

        # Save registers

        movl    %ecx,i386reg_esp(%esp)  # original esp

        movl    %ebp,i386reg_ebp(%esp)

        movl    %ebx,i386reg_ebx(%esp)

        movl    %esi,i386reg_esi(%esp)

        movl    %edi,i386reg_edi(%esp)

        # And interrupt state

        movl    hal_interrupts_enabled,%eax

        movl    %eax,i386reg_interrupts(%esp)

        # Store the context ptr

        movl    %esp,(%edx)

        # Now fall through to hal_thread_load_context

#------------------------------------------------------------------------------

# hal_thread_load_context

# Load thread context

# : 4(%esp) = i386reg_next_context(%esp) = address of sp of thread to execute

# Note that this function is also the second half of hal_thread_switch_context

# and is simply dropped into from it.

#

# %eax, %ecx, and %edx are ours to abuse.

FUNC_START(hal_thread_load_context)

        movl    i386reg_next_context(%esp),%eax # get new context ptr

        movl    (%eax),%eax

        # Restore registers

        movl    i386reg_ebp(%eax),%ebp

        movl    i386reg_ebx(%eax),%ebx

        movl    i386reg_esi(%eax),%esi

        movl    i386reg_edi(%eax),%edi

        movl    i386reg_esp(%eax),%esp

        # And see what needs to happen about interrupts

        movl    i386reg_interrupts(%eax),%eax

        cmpl    hal_interrupts_enabled,%eax

        je      interrupts_ok

        # The saved interrupt state differs from the current one.

        # If interrupts are supposed to be enabled then invoke

        # hal_enable_interrupts. That can be done as a tail call.

        # If interrupts are supposed to be disabled then just

        # update the global variable.

        cmpl    $0,%eax

        jne     hal_enable_interrupts

        movl    %eax,hal_interrupts_enabled

interrupts_ok:

        ret

#------------------------------------------------------------------------------

# HAL longjmp, setjmp implementations

# hal_setjmp saves only to callee save registers ebp, ebx, esi, edi and

# and esp+pc into buffer supplied in 4(esp)

# Note: These definitions are repeated in hal_arch.h. If changes are required

# remember to update both sets.

#define CYGARC_JMP_BUF_SP        0

#define CYGARC_JMP_BUF_EBP       1

#define CYGARC_JMP_BUF_EBX       2

#define CYGARC_JMP_BUF_ESI       3

#define CYGARC_JMP_BUF_EDI       4

#define CYGARC_JMP_BUF_PC        5

#define CYGARC_JMP_BUF_SIZE      6

FUNC_START(hal_setjmp)

        # Get jmpbuf pointer

        movl    4(%esp),%eax

        # Save regular registers

        movl    %ebp,CYGARC_JMP_BUF_EBP*4(%eax)

        movl    %ebx,CYGARC_JMP_BUF_EBX*4(%eax)

        movl    %esi,CYGARC_JMP_BUF_ESI*4(%eax)

        movl    %edi,CYGARC_JMP_BUF_EDI*4(%eax)

        # Stack and PC

        movl    %esp,CYGARC_JMP_BUF_SP*4(%eax)

        movl    0(%esp),%edx

        movl    %edx,CYGARC_JMP_BUF_PC*4(%eax)

        # Return 0

        xor     %eax,%eax

        ret

# hal_longjmp loads state from 4(esp) and returns to PC stored in state

FUNC_START(hal_longjmp)

        # Get return value

        movl    8(%esp),%eax

        # Get jmpbuf pointer

        movl    4(%esp),%ecx

        # Restore regular registers

        movl    CYGARC_JMP_BUF_EBP*4(%ecx),%ebp

        movl    CYGARC_JMP_BUF_EBX*4(%ecx),%ebx

        movl    CYGARC_JMP_BUF_ESI*4(%ecx),%esi

        movl    CYGARC_JMP_BUF_EDI*4(%ecx),%edi

        # Restore stack pointer

        movl    CYGARC_JMP_BUF_SP*4(%ecx),%esp

        # Put return address on stack

        movl    CYGARC_JMP_BUF_PC*4(%ecx),%edx

        movl    %edx,0(%esp)

        ret

#------------------------------------------------------------------------------

# end of linux.S