gdb/config/m68k/tm-linux.h

   1 /* Definitions to target GDB to Linux on m680x0
   2    Copyright (C) 1996,1998 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 /* Number of traps that happen between exec'ing the shell to run an
  21    inferior, and when we finally get to the inferior code.  This is 2
  22    on most implementations.  */
  23
  24 #define START_INFERIOR_TRAPS_EXPECTED 2
  25
  26 /* The following definitions are appropriate when using the ELF
  27    format, where floating point values are returned in fp0, pointer
  28    values in a0 and other values in d0.  */
  29
  30 /* Extract from an array REGBUF containing the (raw) register state a
  31    function return value of type TYPE, and copy that, in virtual
  32    format, into VALBUF.  */
  33
  34 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
  35 {                                                                       \
  36   if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)                                \
  37     {                                                                   \
  38        REGISTER_CONVERT_TO_VIRTUAL (FP0_REGNUM, TYPE,                   \
  39                                     ((char *) (REGBUF)                  \
  40                                      + REGISTER_BYTE (FP0_REGNUM)),     \
  41                                     VALBUF);                            \
  42     }                                                                   \
  43   else if (TYPE_CODE (TYPE) == TYPE_CODE_PTR)                           \
  44     memcpy (VALBUF, (char *) (REGBUF) + REGISTER_BYTE (A0_REGNUM),      \
  45             TYPE_LENGTH (TYPE));                                        \
  46   else                                                                  \
  47     memcpy (VALBUF,                                                     \
  48             ((char *) (REGBUF)                                          \
  49              + (TYPE_LENGTH (TYPE) >= 4 ? 0 : 4 - TYPE_LENGTH (TYPE))), \
  50             TYPE_LENGTH (TYPE));                                        \
  51 }
  52
  53 /* Write into appropriate registers a function return value of type
  54    TYPE, given in virtual format.  */
  55
  56 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
  57 {                                                                       \
  58   if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)                                \
  59     {                                                                   \
  60       char raw_buffer[REGISTER_RAW_SIZE (FP0_REGNUM)];                  \
  61       REGISTER_CONVERT_TO_RAW (TYPE, FP0_REGNUM, VALBUF, raw_buffer);   \
  62       write_register_bytes (REGISTER_BYTE (FP0_REGNUM),                 \
  63                             raw_buffer, TYPE_LENGTH (TYPE));            \
  64     }                                                                   \
  65   else                                                                  \
  66     {                                                                   \
  67       if (TYPE_CODE (TYPE) == TYPE_CODE_PTR)                            \
  68         write_register_bytes (REGISTER_BYTE (A0_REGNUM), VALBUF,        \
  69                               TYPE_LENGTH (TYPE));                      \
  70       write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE));             \
  71     }                                                                   \
  72 }
  73
  74 #include "tm-sysv4.h"
  75 #include "m68k/tm-m68k.h"
  76
  77 /* Extract from an array REGBUF containing the (raw) register state
  78    the address in which a function should return its structure value,
  79    as a CORE_ADDR (or an expression that can be used as one).  */
  80
  81 #undef EXTRACT_STRUCT_VALUE_ADDRESS
  82 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
  83   (*(CORE_ADDR *)((char *) (REGBUF) + REGISTER_BYTE (A0_REGNUM)))
  84
  85 /* Offsets (in target ints) into jmp_buf.  */
  86
  87 #define JB_ELEMENT_SIZE 4
  88 #define JB_PC 7
  89
  90 /* Figure out where the longjmp will land.  Slurp the args out of the stack.
  91    We expect the first arg to be a pointer to the jmp_buf structure from which
  92    we extract the pc (JB_PC) that we will land at.  The pc is copied into ADDR.
  93    This routine returns true on success */
  94
  95 #define GET_LONGJMP_TARGET(ADDR) get_longjmp_target(ADDR)
  96
  97 /* Offset to saved PC in sigcontext, from <asm/sigcontext.h>.  */
  98 #define SIGCONTEXT_PC_OFFSET 26
  99
 100 #undef FRAME_SAVED_PC
 101 #define FRAME_SAVED_PC(FRAME) \
 102   (((FRAME)->signal_handler_caller \
 103     ? sigtramp_saved_pc (FRAME) \
 104     : read_memory_integer ((FRAME)->frame + 4, 4)))
 105
 106 extern CORE_ADDR sigtramp_saved_pc PARAMS ((struct frame_info *));
 107
 108 #define IN_SIGTRAMP(pc,name) in_sigtramp (pc)
 109 extern int in_sigtramp PARAMS ((CORE_ADDR pc));