gdb/config/arm/tm-linux.h

   1 /* Target definitions for GNU/Linux on ARM, for GDB.
   2    Copyright 1999, 2000 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,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #ifndef TM_ARMLINUX_H
  22 #define TM_ARMLINUX_H
  23
  24 #ifdef GDBSERVER
  25 #define ARM_GNULINUX_TARGET
  26 #endif
  27
  28 /* Include the common ARM target definitions.  */
  29 #include "arm/tm-arm.h"
  30
  31 #include "tm-linux.h"
  32
  33 /* Use target-specific function to define link map offsets.  */
  34 extern struct link_map_offsets *arm_linux_svr4_fetch_link_map_offsets (void);
  35 #define SVR4_FETCH_LINK_MAP_OFFSETS() arm_linux_svr4_fetch_link_map_offsets ()
  36
  37 /* Under ARM Linux the traditional way of performing a breakpoint is to
  38    execute a particular software interrupt, rather than use a particular
  39    undefined instruction to provoke a trap.  Upon exection of the software
  40    interrupt the kernel stops the inferior with a SIGTRAP, and wakes the
  41    debugger.  Since ARM Linux is little endian, and doesn't support Thumb
  42    at the moment we redefined ARM_LE_BREAKPOINT to use the correct software
  43    interrupt.  */
  44 #undef ARM_LE_BREAKPOINT
  45 #define ARM_LE_BREAKPOINT       {0x01,0x00,0x9f,0xef}
  46
  47 #undef CALL_DUMMY_WORDS
  48 #define CALL_DUMMY_WORDS arm_linux_call_dummy_words
  49 extern LONGEST arm_linux_call_dummy_words[];
  50
  51 /* Extract from an array REGBUF containing the (raw) register state
  52    a function return value of type TYPE, and copy that, in virtual format,
  53    into VALBUF.  */
  54 struct type;
  55 struct value;
  56 extern void arm_linux_extract_return_value (struct type *, char[], char *);
  57 #undef EXTRACT_RETURN_VALUE
  58 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
  59         arm_linux_extract_return_value ((TYPE), (REGBUF), (VALBUF))
  60
  61 /* Things needed for making the inferior call functions.
  62
  63    FIXME:  This and arm_push_arguments should be merged.  However this
  64            function breaks on a little endian host, big endian target
  65            using the COFF file format.  ELF is ok.
  66
  67            ScottB.  */
  68
  69 #undef PUSH_ARGUMENTS
  70 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
  71      sp = arm_linux_push_arguments ((nargs), (args), (sp), (struct_return), \
  72                                     (struct_addr))
  73 extern CORE_ADDR arm_linux_push_arguments (int, struct value **, CORE_ADDR,
  74                                            int, CORE_ADDR);
  75
  76 /* The first page is not writeable in ARM Linux.  */
  77 #undef LOWEST_PC
  78 #define LOWEST_PC       0x8000
  79
  80 /* Define NO_SINGLE_STEP if ptrace(PT_STEP,...) fails to function correctly
  81    on ARM Linux.  This is the case on 2.0.x kernels, 2.1.x kernels and some
  82    2.2.x kernels.  This will include the implementation of single_step()
  83    in armlinux-tdep.c.  See armlinux-ss.c for more details. */
  84 /* #define NO_SINGLE_STEP       1 */
  85
  86 /* Offset to saved PC in sigcontext structure, from <asm/sigcontext.h> */
  87 #define SIGCONTEXT_PC_OFFSET    (sizeof(unsigned long) * 18)
  88
  89 /* Figure out where the longjmp will land.  The code expects that longjmp
  90    has just been entered and the code had not altered the registers, so
  91    the arguments are are still in r0-r1.  r0 points at the jmp_buf structure
  92    from which the target pc (JB_PC) is extracted.  This pc value is copied
  93    into ADDR.  This routine returns true on success */
  94 extern int arm_get_longjmp_target (CORE_ADDR *);
  95 #define GET_LONGJMP_TARGET(addr)        arm_get_longjmp_target (addr)
  96
  97 /* On ARM Linux, each call to a library routine goes through a small piece
  98    of trampoline code in the ".plt" section.  The  wait_for_inferior()
  99    routine uses this macro to detect when we have stepped into one of
 100    these fragments.  We do not use lookup_solib_trampoline_symbol_by_pc,
 101    because we cannot always find the shared library trampoline symbols.  */
 102 extern int in_plt_section (CORE_ADDR, char *);
 103 #define IN_SOLIB_CALL_TRAMPOLINE(pc, name) in_plt_section((pc), (name))
 104
 105 /* On ARM Linux, a call to a library routine does not have to go through
 106    any trampoline code.  */
 107 #define IN_SOLIB_RETURN_TRAMPOLINE(pc, name)    0
 108
 109 /* If PC is in a shared library trampoline code, return the PC
 110    where the function itself actually starts.  If not, return 0.  */
 111 extern CORE_ADDR find_solib_trampoline_target (CORE_ADDR pc);
 112 #define SKIP_TRAMPOLINE_CODE(pc)  find_solib_trampoline_target (pc)
 113
 114 /* When we call a function in a shared library, and the PLT sends us
 115    into the dynamic linker to find the function's real address, we
 116    need to skip over the dynamic linker call.  This function decides
 117    when to skip, and where to skip to.  See the comments for
 118    SKIP_SOLIB_RESOLVER at the top of infrun.c.  */
 119 extern CORE_ADDR arm_linux_skip_solib_resolver (CORE_ADDR pc);
 120 #define SKIP_SOLIB_RESOLVER arm_linux_skip_solib_resolver
 121
 122 /* When we call a function in a shared library, and the PLT sends us
 123    into the dynamic linker to find the function's real address, we
 124    need to skip over the dynamic linker call.  This function decides
 125    when to skip, and where to skip to.  See the comments for
 126    SKIP_SOLIB_RESOLVER at the top of infrun.c.  */
 127 #if 0
 128 #undef IN_SOLIB_DYNSYM_RESOLVE_CODE
 129 extern CORE_ADDR arm_in_solib_dynsym_resolve_code (CORE_ADDR pc, char *name);
 130 #define IN_SOLIB_DYNSYM_RESOLVE_CODE  arm_in_solib_dynsym_resolve_code
 131 /* ScottB: Current definition is
 132 extern CORE_ADDR in_svr4_dynsym_resolve_code (CORE_ADDR pc, char *name);
 133 #define IN_SOLIB_DYNSYM_RESOLVE_CODE  in_svr4_dynsym_resolve_code */
 134 #endif
 135
 136 /* When the ARM Linux kernel invokes a signal handler, the return
 137    address points at a special instruction which'll trap back into
 138    the kernel.  These definitions are used to identify this bit of
 139    code as a signal trampoline in order to support backtracing
 140    through calls to signal handlers. */
 141
 142 int arm_linux_in_sigtramp (CORE_ADDR pc, char *name);
 143 #define IN_SIGTRAMP(pc, name) arm_linux_in_sigtramp (pc, name)
 144
 145 /* Each OS has different mechanisms for accessing the various
 146    registers stored in the sigcontext structure.  These definitions
 147    provide a mechanism by which the generic code in arm-tdep.c can
 148    find the addresses at which various registers are saved at in the
 149    sigcontext structure.  If SIGCONTEXT_REGISTER_ADDRESS is not
 150    defined, arm-tdep.c will define it to be 0.  (See ia64-tdep.c and
 151    ia64-linux-tdep.c to see what a similar mechanism looks like when
 152    multi-arched.) */
 153
 154 extern CORE_ADDR arm_linux_sigcontext_register_address (CORE_ADDR, CORE_ADDR,
 155                                                         int);
 156 #define SIGCONTEXT_REGISTER_ADDRESS arm_linux_sigcontext_register_address
 157
 158 #endif /* TM_ARMLINUX_H */