Changeset 3b7e9bc in rtems


Ignore:
Timestamp:
05/15/09 07:20:38 (13 years ago)
Author:
Thomas Doerfler <Thomas.Doerfler@…>
Branches:
4.10, 4.11, 5, master
Children:
4670d91
Parents:
6ec6ceb9
Message:

cpu.c, cpu_asm.S, rtems/score/cpu.h: Cleanup of the floating point context initialization, save and restore code.

Location:
cpukit/score/cpu/m68k
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • cpukit/score/cpu/m68k/ChangeLog

    r6ec6ceb9 r3b7e9bc  
     12009-05-11      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * cpu.c, cpu_asm.S, rtems/score/cpu.h: Cleanup of the floating point
     4        context initialization, save and restore code.
     5
    162009-03-12      Joel Sherrill <joel.sherrill@OARcorp.com>
    27
  • cpukit/score/cpu/m68k/cpu.c

    r6ec6ceb9 r3b7e9bc  
    1414#include <rtems/system.h>
    1515#include <rtems/score/isr.h>
     16
     17#if defined( __mcoldfire__ ) && ( M68K_HAS_FPU == 1 )
     18  uint32_t _CPU_cacr_shadow;
     19#endif
    1620
    1721/*  _CPU_Initialize
     
    186190extern Context_Control_fp _fpCCR;
    187191
    188 void CPU_Context_save_fp (Context_Control_fp **fp_context_ptr)
     192void _CPU_Context_save_fp (Context_Control_fp **fp_context_ptr)
    189193{
    190194  Context_Control_fp *fp;
     
    195199}
    196200
    197 void CPU_Context_restore_fp (Context_Control_fp **fp_context_ptr)
     201void _CPU_Context_restore_fp (Context_Control_fp **fp_context_ptr)
    198202{
    199203  Context_Control_fp *fp;
  • cpukit/score/cpu/m68k/cpu_asm.S

    r6ec6ceb9 r3b7e9bc  
    1616
    1717#include <rtems/asm.h>
    18         .data
    19 
    20 #if (defined(__mcoldfire__))
    21 #if ( M68K_HAS_FPU == 1 )
    22 PUBLIC (_CPU_cacr_shadow)     
    23 SYM (_CPU_cacr_shadow):   
    24          .long 1
    25 #endif
    26 #endif
    27 
    28         .text
    2918
    3019/*  void _CPU_Context_switch( run_context, heir_context )
     
    4635          moval    a7@(HEIRCONTEXT_ARG),a0| a0 = heir thread context
    4736
    48 #if (defined(__mcoldfire__))
    49 #if ( M68K_HAS_FPU == 1 )         
    50           moveb    a0@(13*4),d0                 | get context specific DF bit info in d0   
    51           btstb    #4,d0                        | test context specific DF bit info
     37#if defined( __mcoldfire__ ) && ( M68K_HAS_FPU == 1 )
     38          moveb    a0@(13*4),d0                 | get context specific DF bit info in d0
     39          btstb    #4,d0                        | test context specific DF bit info
    5240          beq      fpu_on                       | branch if FPU needs to be switched on
    53          
    54 fpu_off:  movl     _CPU_cacr_shadow,d0          | get content of _CPU_cacr_shadow in d0     
     41
     42fpu_off:  movl     _CPU_cacr_shadow,d0          | get content of _CPU_cacr_shadow in d0
    5543          btstl    #4,d0                        | test DF bit info in d0
    56           bne      restore                      | branch if FPU is already switched off     
     44          bne      restore                      | branch if FPU is already switched off
    5745          bsetl    #4,d0                        | set DF bit in d0
    58           bra      cacr_set                     | branch to set the new FPU setting in cacr and _CPU_cacr_shadow   
    59          
    60 fpu_on:   movl     _CPU_cacr_shadow,d0          | get content of _CPU_cacr_shadow in d1       
    61           btstl    #4,d0                        | test context specific DF bit info
    62           beq      restore                      | branch if FPU is already switched on   
     46          bra      cacr_set                     | branch to set the new FPU setting in cacr and _CPU_cacr_shadow
     47
     48fpu_on:   movl     _CPU_cacr_shadow,d0          | get content of _CPU_cacr_shadow in d1
     49          btstl    #4,d0                        | test context specific DF bit info
     50          beq      restore                      | branch if FPU is already switched on
    6351          bclrl    #4,d0                        | clear DF bit info in d0
    64          
     52
    6553cacr_set: movew    sr,d1                        | get content of sr in d1
    66           oril     #0x00000700,d1               | mask d1 
     54          oril     #0x00000700,d1               | mask d1
    6755          movew    d1,sr                        | disable all interrupts
    6856          movl     d0,_CPU_cacr_shadow          | move _CPU_cacr_shadow to d1
    69           movec    d0,cacr                      | enable FPU in cacr             
    70 #endif
     57          movec    d0,cacr                      | enable FPU in cacr
    7158#endif
    7259
     
    7562          rts
    7663
    77 /*PAGE
    78  *  void __CPU_Context_save_fp_context( &fp_context_ptr )
    79  *  void __CPU_Context_restore_fp_context( &fp_context_ptr )
    80  *
    81  *  These routines are used to context switch a MC68881 or MC68882.
    82  *
    83  *  NOTE:  Context save and restore code is based upon the code shown
    84  *         on page 6-38 of the MC68881/68882 Users Manual (rev 1).
    85  *
    86  *         CPU_FP_CONTEXT_SIZE is higher than expected to account for the
    87  *         -1 pushed at end of this sequence.
    88  *
    89  *         Neither of these entries is required if we have software FPU
    90  *         emulation.  But if we don't have an FPU or emulation, then
    91  *         we need the stub versions of these routines.
    92  */
    93 
    94 #if (CPU_SOFTWARE_FP == FALSE)
     64/*
     65 * Floating point context save and restore.
     66 *
     67 * The code for the MC68881 or MC68882 is based upon the code shown on pages
     68 * 6-38 of the MC68881/68882 Users Manual (rev 1).  CPU_FP_CONTEXT_SIZE is
     69 * higher than expected to account for the -1 pushed at end of this sequence.
     70 */
     71
     72#if ( CPU_HARDWARE_FP == TRUE )
    9573
    9674.set FPCONTEXT_ARG,   4                   | save FP context argument
    97 .set FP_STATE_SAVED,  (4*4)               | FPU state is 4 longwords
    98 .set FP_REGS_SAVED,   (8*8)               | FPU regs is 8 64bit values
    9975
    10076        .align  4
    10177        .global SYM (_CPU_Context_save_fp)
    10278SYM (_CPU_Context_save_fp):
    103 #if ( M68K_HAS_FPU == 1 )
    104 #if (defined(__mcoldfire__))
    105        
    106         moval    a7@(FPCONTEXT_ARG),a1    | a1 = &ptr to context area
    107         moval    a1@,a0                   | a0 = Save context area
    108         leal     a0@(-16),a0              | open context frame for coldfire state frame
    109         fsave    a0@                      | save coldfire state frame   
    110         tstb     a0@                      | check for a null frame
    111         beq.b    nosave                   | Yes, skip save of user model
    112         leal     a0@(-64),a0              | open context frame for coldfire data registers (fp0-fp7)
    113         fmovem   fp0-fp7,a0@              | save coldfire data registers (fp0-fp7)                     
    114         movl     #-1,a0@-                 | place not-null flag on stack
    115 nosave: movl     a0,a1@                   | save pointer to saved context
    116 
    117 #if ( M68K_HAS_EMAC == 1 )
    118 
    119         movel    macsr,d0                 | store content of macsr in d0
    120         clrl     d1                       | clear d1
    121         movl     d1,macsr                 | disable rounding in macsr
    122         movl     acc0,d1                  | store content of acc0 in d1
    123         moveml   d0-d1,a0@(-8)            | save EMAC macsr/acc0
    124         movl     acc1,d0                  | store acc1 in d0
    125         movl     acc2,d1                  | store acc2 in d1
    126         moveml   d0-d1,a0@(-16)           | save EMAC acc1/acc2 with offset
    127         movl     acc3,d0                  | store acc3 in d0
    128         movl     accext01,d1              | store acc2 in d1
    129         moveml   d0-d1,a0@(-24)           | save EMAC acc3/accext01 with offset
    130         movl     accext23,d0              | store accext23 in d0
    131         movl     mask,d1                  | store mask in d1
    132         moveml   d0-d1,a0@(-32)           | save EMAC accext23/mask with offset
    133         leal     a0@(-32),a0              | set a0 to the begin of coldfire data registers frame (fp0-fp7)
    134         movl     a0,a1@                   | save pointer to saved context
    135 
    136 #endif
    137      
    138 #else
    139 
    140         moval    a7@(FPCONTEXT_ARG),a1    | a1 = &ptr to context area
    141         moval    a1@,a0                   | a0 = Save context area
    142 #if ( !defined(__mcoldfire__) && !__mc68060__ )
     79
     80        /* Get context save area pointer argument from the stack */
     81        moval    a7@(FPCONTEXT_ARG), a1
     82        moval    a1@, a0
     83
     84  #if defined( __mcoldfire__ )
     85        /* Move MACSR to data register and disable rounding */
     86        movel    macsr, d0
     87        clrl     d1
     88        movl     d1, macsr
     89
     90        /* Save MACSR and ACC0 */
     91        movl     acc0, d1
     92        moveml   d0-d1, a0@(0)
     93
     94        /* Save ACC1 and ACC2 */
     95        movl     acc1, d0
     96        movl     acc2, d1
     97        moveml   d0-d1, a0@(8)
     98
     99        /* Save ACC3 and ACCEXT01 */
     100        movl     acc3, d0
     101        movl     accext01, d1
     102        moveml   d0-d1, a0@(16)
     103
     104        /* Save ACCEXT23 and MASK */
     105        movl     accext23, d0
     106        movl     mask, d1
     107        moveml   d0-d1, a0@(24)
     108
     109    #if ( M68K_HAS_FPU == 1 )
     110        /* Save FP state */
     111        fsave    a0@(32)
     112
     113        /* Save FP instruction address */
     114        fmovel   fpi, a0@(48)
     115
     116        /* Save FP data */
     117        fmovem   fp0-fp7, a0@(52)
     118    #endif
     119  #else
     120    #if defined( __mc68060__ )
     121        lea      a0@(-M68K_FP_STATE_SIZE), a0
     122        fsave    a0@                      | save 68060 state frame
     123    #else
    143124        fsave    a0@-                     | save 68881/68882 state frame
    144 #else
    145         lea      a0@(-FP_STATE_SAVED),a0  | save the state of the FPU
    146         fsave    a0@                      | on a Coldfire and 68060.
    147 #endif
     125    #endif
    148126        tstb     a0@                      | check for a null frame
    149127        beq.b    nosv                     | Yes, skip save of user model
    150 #if ( !defined(__mcoldfire__) )
    151         fmovem   fp0-fp7,a0@-             | save data registers (fp0-fp7)
    152         fmovem   fpc/fps/fpi,a0@-         | and save control registers
    153 #else
    154         lea      a0@(-FP_REGS_SAVED),a0
    155         fmovem   fp0-fp7,a0@              | save data registers (fp0-fp7)
    156         fmove.l  fpc,a0@-                 | and save control registers
    157         fmove.l  fps,a0@-
    158         fmove.l  fpi,a0@-
    159 #endif
    160         movl     #-1,a0@-                 | place not-null flag on stack
    161 nosv:   movl     a0,a1@                   | save pointer to saved context
    162 
    163 #endif
    164 #endif
     128        fmovem   fp0-fp7, a0@-            | save data registers (fp0-fp7)
     129        fmovem   fpc/fps/fpi, a0@-        | and save control registers
     130        movl     #-1, a0@-                | place not-null flag on stack
     131nosv:
     132        movl     a0, a1@                  | save pointer to saved context
     133  #endif
     134
     135        /* Return */
    165136        rts
    166137
     
    168139        .global SYM (_CPU_Context_restore_fp)
    169140SYM (_CPU_Context_restore_fp):
    170 #if ( M68K_HAS_FPU == 1 )
    171 
    172 #if (defined(__mcoldfire__))
    173 
    174         moval    a7@(FPCONTEXT_ARG),a1    | a1 = &ptr to context area
    175         moval    a1@,a0                   | a0 = address of saved context
    176        
    177 #if ( M68K_HAS_EMAC == 1 )
    178 
    179         clrl     d0                       | clear d0
    180         movl     d0,macsr                 | disable roundrounding in macsr
    181         moveml   a0@(0),d0-d1             | get mask/accext23 in d0/d1
    182         movl     d0,mask                  | restore mask
    183         movl     d1,accext23              | restore accext23
    184         moveml   a0@(8),d0-d1             | get accext01/acc3 in d0/d1
    185         movl     d0,accext01              | restore accext01
    186         movl     d1,acc3                  | restore acc3
    187         moveml   a0@(16),d0-d1            | get acc2/acc1 in d0/d1
    188         movl     d0,acc2                  | restore acc2
    189         movl     d1,acc1                  | restore acc1
    190         moveml   a0@(24),d0-d1            | get acc0/macsr in d0/d1
    191         movl     d0,acc0                  | restore acc0
    192         movl     d1,macsr                 | restore macsr
    193         leal     a0@(32),a0               | set a0 to the begin of coldfire FPU frame
    194  
    195 #endif
    196                
    197         tstb     a0@                      | Null context frame?
    198         beq.b    norest                   | Yes, skip fp restore
    199         addql    #4,a0                    | throwaway non-null flag
    200         fmovem   a0@,fp0-fp7              | restore data regs (fp0-fp7)
    201         leal     a0@(+64),a0              | close context frame for coldfire data registers (fp0-fp7)
    202 norest: frestore a0@                      | restore the fp state frame
    203         leal     a0@(+16),a0              | close context frame for coldfire state frame
    204         movl     a0,a1@                   | save pointer to saved context
    205 
    206 #else
    207 
    208         moval    a7@(FPCONTEXT_ARG),a1    | a1 = &ptr to context area
    209         moval    a1@,a0                   | a0 = address of saved context
     141
     142        /* Get context save area pointer argument from the stack */
     143        moval    a7@(FPCONTEXT_ARG), a1
     144        moval    a1@, a0
     145
     146  #if defined( __mcoldfire__ )
     147    #if ( M68K_HAS_FPU == 1 )
     148        /* Restore FP data */
     149        fmovem   a0@(52), fp0-fp7
     150
     151        /* Restore FP instruction address */
     152        fmovel   a0@(48), fpi
     153
     154        /* Restore FP state */
     155        frestore a0@(32)
     156    #endif
     157
     158        /* Disable rounding */
     159        clrl     d0
     160        movl     d0, macsr
     161
     162        /* Restore MASK and ACCEXT23 */
     163        moveml   a0@(24), d0-d1
     164        movl     d0, mask
     165        movl     d1, accext23
     166
     167        /* Restore ACCEXT01 and ACC3 */
     168        moveml   a0@(16), d0-d1
     169        movl     d0, accext01
     170        movl     d1, acc3
     171
     172        /* Restore ACC2 and ACC1 */
     173        moveml   a0@(8), d0-d1
     174        movl     d0, acc2
     175        movl     d1, acc1
     176
     177        /* Restore ACC0 and MACSR */
     178        moveml   a0@(0), d0-d1
     179        movl     d0, acc0
     180        movl     d1, macsr
     181  #else
    210182        tstb     a0@                      | Null context frame?
    211183        beq.b    norst                    | Yes, skip fp restore
    212         addql    #4,a0                    | throwaway non-null flag
    213 #if ( !defined(__mcoldfire__) )
    214         fmovem   a0@+,fpc/fps/fpi         | restore control registers
    215         fmovem   a0@+,fp0-fp7             | restore data regs (fp0-fp7)
    216 norst:  frestore a0@+                     | restore the fp state frame
    217 #else
    218         fmove.l  a0@+,fpc                 | restore control registers
    219         fmove.l  a0@+,fps   
    220         fmove.l  a0@+,fpi
    221         fmovem   a0@,fp0-fp7              | restore data regs (fp0-fp7)
    222         lea      a0@(FP_REGS_SAVED),a0
    223 norst:  frestore a0@                      | restore the fp state frame
    224         lea      a0@(FP_STATE_SAVED),a0
    225 #endif
    226         movl     a0,a1@                   | save pointer to saved context
    227 
    228 #endif
    229 #endif
     184        addql    #4, a0                   | throwaway non-null flag
     185        fmovem   a0@+, fpc/fps/fpi        | restore control registers
     186        fmovem   a0@+, fp0-fp7            | restore data regs (fp0-fp7)
     187norst:
     188    #if defined( __mc68060__ )
     189        frestore a0@                      | restore 68060 state frame
     190        lea      a0@(M68K_FP_STATE_SIZE), a0
     191    #else
     192        frestore a0@+                     | restore 68881/68882 state frame
     193    #endif
     194        movl     a0, a1@                  | save pointer to saved context
     195  #endif
     196
     197        /* Return */
    230198        rts
    231199#endif
     
    258226.set FVO_OFFSET,   0                     | Format/vector offset placed in the stack
    259227#endif /* M68K_HAS_VBR */
    260  
     228
    261229.set SAVED,        16                    | space for saved registers
    262230
     
    293261
    294262        addql   #1,SYM(_ISR_Nest_level) | one nest level deeper
    295        
     263
    296264        movel   SYM (_ISR_Vector_table),a0 | a0= base of RTEMS table
    297265#if ( M68K_HAS_PREINDEXING == 1 )
     
    335303  #if ( !defined(__mcoldfire__) && !__mc68060__ )
    336304        cmpl    #_ISR_Handler,a7@(SAVED+PC_OFFSET)
    337         beq.b   exit       
     305        beq.b   exit
    338306  #endif
    339307#endif
  • cpukit/score/cpu/m68k/rtems/score/cpu.h

    r6ec6ceb9 r3b7e9bc  
    2626#include <rtems/score/m68k.h>              /* pick up machine definitions */
    2727#ifndef ASM
    28 #include <rtems/score/types.h>
     28  #include <rtems/score/types.h>
     29#else
     30  /* FIXME */
     31  #define TRUE 1
     32  #define FALSE 0
    2933#endif
    3034
     
    7882 */
    7983
    80 #if ( M68K_HAS_FPU == 1 )
    81 #define CPU_HARDWARE_FP    TRUE
    82 #define CPU_SOFTWARE_FP    FALSE
     84#if ( M68K_HAS_FPU == 1 ) || ( M68K_HAS_EMAC == 1 )
     85  #define CPU_HARDWARE_FP TRUE
     86  #define CPU_SOFTWARE_FP FALSE
    8387#else
    84 #define CPU_HARDWARE_FP    FALSE
    85 #if defined(__GNUC__)
    86 #define CPU_SOFTWARE_FP    TRUE
    87 #else
    88 #define CPU_SOFTWARE_FP    FALSE
    89 #endif
     88  #define CPU_HARDWARE_FP FALSE
     89  #if defined( __GNUC__ )
     90    #define CPU_SOFTWARE_FP TRUE
     91  #else
     92    #define CPU_SOFTWARE_FP FALSE
     93  #endif
    9094#endif
    9195
     
    114118
    115119#ifndef ASM
     120
    116121/* structures */
    117122
     
    134139  void       *a6;                /* (a6) address register 6 */
    135140  void       *a7_msp;            /* (a7) master stack pointer */
    136 
    137 #if (defined(__mcoldfire__))
    138 #if ( M68K_HAS_FPU == 1 )
    139   uint8_t   fpu_dis;
    140 #endif
    141 #endif
    142 
    143 }   Context_Control;
     141  #if defined( __mcoldfire__ ) && ( M68K_HAS_FPU == 1 )
     142    uint8_t   fpu_dis;
     143  #endif
     144} Context_Control;
    144145
    145146#define _CPU_Context_Get_SP( _context ) \
     
    147148
    148149/*
    149  *  Floating point context ares
    150  */
    151 
    152 #if (CPU_SOFTWARE_FP == TRUE)
    153 
    154 /*
    155  *  This is the same as gcc's view of the software FP condition code
    156  *  register _fpCCR.  The implementation of the emulation code is
    157  *  in the gcc-VERSION/config/m68k directory.  This structure is
    158  *  correct as of gcc 2.7.2.2.
    159  */
    160 
    161 typedef struct {
    162   uint16_t     _exception_bits;
    163   uint16_t     _trap_enable_bits;
    164   uint16_t     _sticky_bits;
    165   uint16_t     _rounding_mode;
    166   uint16_t     _format;
    167   uint16_t     _last_operation;
    168   union {
    169     float sf;
    170     double df;
    171   } _operand1;
    172   union {
    173     float sf;
    174     double df;
    175   } _operand2;
    176 } Context_Control_fp;
    177 
    178 #elif (defined(__mcoldfire__))
    179 
    180 /*
    181  *  FP context save area for the ColdFire core numeric coprocessors
    182  */
    183 typedef struct {
    184   uint8_t     fp_save_area[84];     /*    16 bytes for FSAVE/FRESTORE    */
    185                                     /*    64 bytes for FMOVEM FP0-7      */
    186                                     /*     4 bytes for non-null flag     */
    187 
    188 #if (M68K_HAS_EMAC == 1)
    189 
    190 /*
    191  *  EMAC context save area for the ColdFire core
    192  */
    193   uint8_t     emac_save_area[32];   /*  32 bytes for EMAC registers      */
    194 
    195 #endif
    196 
    197 } Context_Control_fp;
    198 
    199 #if ( M68K_HAS_FPU == 1 )
    200 extern uint32_t _CPU_cacr_shadow;
    201 #endif
    202 
    203 #else
    204 /*
    205  *  FP context save area for the M68881/M68882 numeric coprocessors.
    206  */
    207 typedef struct {
    208   uint8_t     fp_save_area[332];    /*   216 bytes for FSAVE/FRESTORE    */
    209                                     /*    96 bytes for FMOVEM FP0-7      */
    210                                     /*    12 bytes for FMOVEM CREGS      */
    211                                     /*     4 bytes for non-null flag     */
    212 } Context_Control_fp;
     150 *  Floating point context areas and support routines
     151 */
     152
     153#if ( CPU_SOFTWARE_FP == TRUE )
     154  /*
     155   *  This is the same as gcc's view of the software FP condition code
     156   *  register _fpCCR.  The implementation of the emulation code is
     157   *  in the gcc-VERSION/config/m68k directory.  This structure is
     158   *  correct as of gcc 2.7.2.2.
     159   */
     160  typedef struct {
     161    uint16_t _exception_bits;
     162    uint16_t _trap_enable_bits;
     163    uint16_t _sticky_bits;
     164    uint16_t _rounding_mode;
     165    uint16_t _format;
     166    uint16_t _last_operation;
     167    union {
     168      float sf;
     169      double df;
     170    } _operand1;
     171    union {
     172      float sf;
     173      double df;
     174    } _operand2;
     175  } Context_Control_fp;
     176
     177  /*
     178   *  This software FP implementation is only for GCC.
     179   */
     180  #define _CPU_Context_Fp_start( _base, _offset ) \
     181     ((void *) _Addresses_Add_offset( (_base), (_offset) ) )
     182
     183  #define _CPU_Context_Initialize_fp( _fp_area ) \
     184     { \
     185       Context_Control_fp *_fp; \
     186       _fp = *(Context_Control_fp **)_fp_area; \
     187       _fp->_exception_bits = 0; \
     188       _fp->_trap_enable_bits = 0; \
     189       _fp->_sticky_bits = 0; \
     190       _fp->_rounding_mode = 0;  /* ROUND_TO_NEAREST */ \
     191       _fp->_format = 0;         /* NIL */ \
     192       _fp->_last_operation = 0; /* NOOP */ \
     193       _fp->_operand1.df = 0; \
     194       _fp->_operand2.df = 0; \
     195     }
     196#endif
     197
     198#if ( CPU_HARDWARE_FP == TRUE )
     199  #if defined( __mcoldfire__ )
     200    /* We need memset() to initialize the FP context */
     201    #include <string.h>
     202
     203    #if ( M68K_HAS_FPU == 1 )
     204      /*
     205       * The Cache Control Register (CACR) has write-only access.  It is also
     206       * used to enable and disable the FPU.  We need to maintain a copy of
     207       * this register to allow per thread values.
     208       */
     209      extern uint32_t _CPU_cacr_shadow;
     210    #endif
     211
     212    /* We assume that each ColdFire core with a FPU has also an EMAC unit */
     213    typedef struct {
     214      uint32_t emac_macsr;
     215      uint32_t emac_acc0;
     216      uint32_t emac_acc1;
     217      uint32_t emac_acc2;
     218      uint32_t emac_acc3;
     219      uint32_t emac_accext01;
     220      uint32_t emac_accext23;
     221      uint32_t emac_mask;
     222      #if ( M68K_HAS_FPU == 1 )
     223        uint16_t fp_state_format;
     224        uint16_t fp_state_fpcr;
     225        double fp_state_op;
     226        uint32_t fp_state_fpsr;
     227
     228        /*
     229         * We need to save the FP Instruction Address Register (FPIAR), because
     230         * a context switch can occur within a FP exception before the handler
     231         * was able to save this register.
     232         */
     233        uint32_t fp_fpiar;
     234
     235        double fp_data [8];
     236      #endif
     237    } Context_Control_fp;
     238
     239    #define _CPU_Context_Fp_start( _base, _offset ) \
     240      ((void *) _Addresses_Add_offset( (_base), (_offset) ))
     241
     242    /*
     243     * The reset value for all context relevant registers except the FP data
     244     * registers is zero.  The reset value of the FP data register is NAN.  The
     245     * restore of the reset FP state will reset the FP data registers, so the
     246     * initial value of them can be arbitrary here.
     247     */
     248    #define _CPU_Context_Initialize_fp( _fp_area ) \
     249      memset( *(_fp_area), 0, sizeof( Context_Control_fp ) )
     250  #else
     251    /*
     252     *  FP context save area for the M68881/M68882 and 68060 numeric coprocessors.
     253     */
     254
     255    #if defined( __mc68060__ )
     256      #define M68K_FP_STATE_SIZE 16
     257    #else
     258      #define M68K_FP_STATE_SIZE 216
     259    #endif
     260
     261    typedef struct {
     262      /*
     263       * M68K_FP_STATE_SIZE bytes for FSAVE/FRESTORE
     264       * 96 bytes for FMOVEM FP0-7
     265       * 12 bytes for FMOVEM CREGS
     266       * 4 bytes for non-null flag
     267       */
     268      uint8_t fp_save_area [M68K_FP_STATE_SIZE + 112];
     269    } Context_Control_fp;
     270
     271    #define _CPU_Context_Fp_start( _base, _offset ) \
     272       ( \
     273         (void *) _Addresses_Add_offset( \
     274            (_base), \
     275            (_offset) + CPU_CONTEXT_FP_SIZE - 4 \
     276         ) \
     277       )
     278
     279    #define _CPU_Context_Initialize_fp( _fp_area ) \
     280       { \
     281         uint32_t   *_fp_context = (uint32_t *)*(_fp_area); \
     282         *(--(_fp_context)) = 0; \
     283         *(_fp_area) = (void *)(_fp_context); \
     284       }
     285    #endif
    213286#endif
    214287
     
    265338
    266339#endif /* M68K_HAS_VBR */
     340
    267341#endif /* ASM */
    268342
     
    404478        : "0" ((_the_context)->sr), "1" ((_the_context)->a7_msp) ); \
    405479  }
    406 
    407 /*
    408  *  Floating Point Context Area Support routines
    409  */
    410 
    411 #if (CPU_SOFTWARE_FP == TRUE)
    412 
    413 /*
    414  *  This software FP implementation is only for GCC.
    415  */
    416 
    417 #define _CPU_Context_Fp_start( _base, _offset ) \
    418    ((void *) _Addresses_Add_offset( (_base), (_offset) ) )
    419 
    420 
    421 #define _CPU_Context_Initialize_fp( _fp_area ) \
    422    { \
    423    Context_Control_fp *_fp; \
    424    _fp = *(Context_Control_fp **)_fp_area; \
    425    _fp->_exception_bits = 0; \
    426    _fp->_trap_enable_bits = 0; \
    427    _fp->_sticky_bits = 0; \
    428    _fp->_rounding_mode = 0;  /* ROUND_TO_NEAREST */ \
    429    _fp->_format = 0;         /* NIL */ \
    430    _fp->_last_operation = 0;  /* NOOP */ \
    431    _fp->_operand1.df = 0; \
    432    _fp->_operand2.df = 0; \
    433    }
    434 #else
    435 #define _CPU_Context_Fp_start( _base, _offset ) \
    436    ((void *) \
    437      _Addresses_Add_offset( \
    438         (_base), \
    439         (_offset) + CPU_CONTEXT_FP_SIZE - 4 \
    440      ) \
    441    )
    442 
    443 #if (defined(__mcoldfire__) && ( M68K_HAS_FPU == 1 ))
    444 #define _CPU_Context_Initialize_fp( _fp_area ) \
    445    { uint32_t   *_fp_context = (uint32_t *)*(_fp_area); \
    446      \
    447      *(--(_fp_context)) = 0; \
    448      *(_fp_area) = (void *)(_fp_context); \
    449      asm volatile("movl %0,%%macsr": : "d" (0) ); \
    450    }
    451 #else
    452 #define _CPU_Context_Initialize_fp( _fp_area ) \
    453    { uint32_t   *_fp_context = (uint32_t *)*(_fp_area); \
    454      \
    455      *(--(_fp_context)) = 0; \
    456      *(_fp_area) = (void *)(_fp_context); \
    457    }
    458 #endif
    459 #endif
    460480
    461481/* end of Context handler macros */
Note: See TracChangeset for help on using the changeset viewer.