gdb/m32r-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux m32r.
   2
   3    Copyright (C) 2004 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "defs.h"
  23 #include "gdbcore.h"
  24 #include "frame.h"
  25 #include "value.h"
  26 #include "regcache.h"
  27 #include "inferior.h"
  28 #include "osabi.h"
  29 #include "reggroups.h"
  30 #include "regset.h"
  31
  32 #include "gdb_string.h"
  33
  34 #include "glibc-tdep.h"
  35 #include "solib-svr4.h"
  36
  37 #include "trad-frame.h"
  38 #include "frame-unwind.h"
  39
  40 #include "m32r-tdep.h"
  41 \f
  42
  43 /* Recognizing signal handler frames.  */
  44
  45 /* GNU/Linux has two flavors of signals.  Normal signal handlers, and
  46    "realtime" (RT) signals.  The RT signals can provide additional
  47    information to the signal handler if the SA_SIGINFO flag is set
  48    when establishing a signal handler using `sigaction'.  It is not
  49    unlikely that future versions of GNU/Linux will support SA_SIGINFO
  50    for normal signals too.  */
  51
  52 /* When the m32r Linux kernel calls a signal handler and the
  53    SA_RESTORER flag isn't set, the return address points to a bit of
  54    code on the stack.  This function returns whether the PC appears to
  55    be within this bit of code.
  56
  57    The instruction sequence for normal signals is
  58        ldi    r7, #__NR_sigreturn
  59        trap   #2
  60    or 0x67 0x77 0x10 0xf2.
  61
  62    Checking for the code sequence should be somewhat reliable, because
  63    the effect is to call the system call sigreturn.  This is unlikely
  64    to occur anywhere other than in a signal trampoline.
  65
  66    It kind of sucks that we have to read memory from the process in
  67    order to identify a signal trampoline, but there doesn't seem to be
  68    any other way.  Therefore we only do the memory reads if no
  69    function name could be identified, which should be the case since
  70    the code is on the stack.
  71
  72    Detection of signal trampolines for handlers that set the
  73    SA_RESTORER flag is in general not possible.  Unfortunately this is
  74    what the GNU C Library has been doing for quite some time now.
  75    However, as of version 2.1.2, the GNU C Library uses signal
  76    trampolines (named __restore and __restore_rt) that are identical
  77    to the ones used by the kernel.  Therefore, these trampolines are
  78    supported too.  */
  79
  80 static const gdb_byte linux_sigtramp_code[] = {
  81   0x67, 0x77, 0x10, 0xf2,
  82 };
  83
  84 /* If PC is in a sigtramp routine, return the address of the start of
  85    the routine.  Otherwise, return 0.  */
  86
  87 static CORE_ADDR
  88 m32r_linux_sigtramp_start (CORE_ADDR pc, struct frame_info *next_frame)
  89 {
  90   gdb_byte buf[4];
  91
  92   /* We only recognize a signal trampoline if PC is at the start of
  93      one of the instructions.  We optimize for finding the PC at the
  94      start of the instruction sequence, as will be the case when the
  95      trampoline is not the first frame on the stack.  We assume that
  96      in the case where the PC is not at the start of the instruction
  97      sequence, there will be a few trailing readable bytes on the
  98      stack.  */
  99
 100   if (pc % 2 != 0)
 101     {
 102       if (!safe_frame_unwind_memory (next_frame, pc, buf, 2))
 103         return 0;
 104
 105       if (memcmp (buf, linux_sigtramp_code, 2) == 0)
 106         pc -= 2;
 107       else
 108         return 0;
 109     }
 110
 111   if (!safe_frame_unwind_memory (next_frame, pc, buf, 4))
 112     return 0;
 113
 114   if (memcmp (buf, linux_sigtramp_code, 4) != 0)
 115     return 0;
 116
 117   return pc;
 118 }
 119
 120 /* This function does the same for RT signals.  Here the instruction
 121    sequence is
 122        ldi    r7, #__NR_rt_sigreturn
 123        trap   #2
 124    or 0x97 0xf0 0x00 0xad 0x10 0xf2 0xf0 0x00.
 125
 126    The effect is to call the system call rt_sigreturn.  */
 127
 128 static const gdb_byte linux_rt_sigtramp_code[] = {
 129   0x97, 0xf0, 0x00, 0xad, 0x10, 0xf2, 0xf0, 0x00,
 130 };
 131
 132 /* If PC is in a RT sigtramp routine, return the address of the start
 133    of the routine.  Otherwise, return 0.  */
 134
 135 static CORE_ADDR
 136 m32r_linux_rt_sigtramp_start (CORE_ADDR pc, struct frame_info *next_frame)
 137 {
 138   gdb_byte buf[4];
 139
 140   /* We only recognize a signal trampoline if PC is at the start of
 141      one of the instructions.  We optimize for finding the PC at the
 142      start of the instruction sequence, as will be the case when the
 143      trampoline is not the first frame on the stack.  We assume that
 144      in the case where the PC is not at the start of the instruction
 145      sequence, there will be a few trailing readable bytes on the
 146      stack.  */
 147
 148   if (pc % 2 != 0)
 149     return 0;
 150
 151   if (!safe_frame_unwind_memory (next_frame, pc, buf, 4))
 152     return 0;
 153
 154   if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
 155     {
 156       if (!safe_frame_unwind_memory (next_frame, pc + 4, buf, 4))
 157         return 0;
 158
 159       if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0)
 160         return pc;
 161     }
 162   else if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0)
 163     {
 164       if (!safe_frame_unwind_memory (next_frame, pc - 4, buf, 4))
 165         return 0;
 166
 167       if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
 168         return pc - 4;
 169     }
 170
 171   return 0;
 172 }
 173
 174 static int
 175 m32r_linux_pc_in_sigtramp (CORE_ADDR pc, char *name,
 176                            struct frame_info *next_frame)
 177 {
 178   /* If we have NAME, we can optimize the search.  The trampolines are
 179      named __restore and __restore_rt.  However, they aren't dynamically
 180      exported from the shared C library, so the trampoline may appear to
 181      be part of the preceding function.  This should always be sigaction,
 182      __sigaction, or __libc_sigaction (all aliases to the same function).  */
 183   if (name == NULL || strstr (name, "sigaction") != NULL)
 184     return (m32r_linux_sigtramp_start (pc, next_frame) != 0
 185             || m32r_linux_rt_sigtramp_start (pc, next_frame) != 0);
 186
 187   return (strcmp ("__restore", name) == 0
 188           || strcmp ("__restore_rt", name) == 0);
 189 }
 190
 191 /* From <asm/sigcontext.h>.  */
 192 static int m32r_linux_sc_reg_offset[] = {
 193   4 * 4,                        /* r0 */
 194   5 * 4,                        /* r1 */
 195   6 * 4,                        /* r2 */
 196   7 * 4,                        /* r3 */
 197   0 * 4,                        /* r4 */
 198   1 * 4,                        /* r5 */
 199   2 * 4,                        /* r6 */
 200   8 * 4,                        /* r7 */
 201   9 * 4,                        /* r8 */
 202   10 * 4,                       /* r9 */
 203   11 * 4,                       /* r10 */
 204   12 * 4,                       /* r11 */
 205   13 * 4,                       /* r12 */
 206   21 * 4,                       /* fp */
 207   22 * 4,                       /* lr */
 208   -1 * 4,                       /* sp */
 209   16 * 4,                       /* psw */
 210   -1 * 4,                       /* cbr */
 211   23 * 4,                       /* spi */
 212   20 * 4,                       /* spu */
 213   19 * 4,                       /* bpc */
 214   17 * 4,                       /* pc */
 215   15 * 4,                       /* accl */
 216   14 * 4                        /* acch */
 217 };
 218
 219 struct m32r_frame_cache
 220 {
 221   CORE_ADDR base, pc;
 222   struct trad_frame_saved_reg *saved_regs;
 223 };
 224
 225 static struct m32r_frame_cache *
 226 m32r_linux_sigtramp_frame_cache (struct frame_info *next_frame,
 227                                  void **this_cache)
 228 {
 229   struct m32r_frame_cache *cache;
 230   CORE_ADDR sigcontext_addr, addr;
 231   int regnum;
 232
 233   if ((*this_cache) != NULL)
 234     return (*this_cache);
 235   cache = FRAME_OBSTACK_ZALLOC (struct m32r_frame_cache);
 236   (*this_cache) = cache;
 237   cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 238
 239   cache->base = frame_unwind_register_unsigned (next_frame, M32R_SP_REGNUM);
 240   sigcontext_addr = cache->base + 4;
 241
 242   cache->pc = frame_pc_unwind (next_frame);
 243   addr = m32r_linux_sigtramp_start (cache->pc, next_frame);
 244   if (addr == 0)
 245     {
 246       /* If this is a RT signal trampoline, adjust SIGCONTEXT_ADDR
 247          accordingly.  */
 248       addr = m32r_linux_rt_sigtramp_start (cache->pc, next_frame);
 249       if (addr)
 250         sigcontext_addr += 128;
 251       else
 252         addr = frame_func_unwind (next_frame);
 253     }
 254   cache->pc = addr;
 255
 256   cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 257
 258   for (regnum = 0; regnum < sizeof (m32r_linux_sc_reg_offset) / 4; regnum++)
 259     {
 260       if (m32r_linux_sc_reg_offset[regnum] >= 0)
 261         cache->saved_regs[regnum].addr =
 262           sigcontext_addr + m32r_linux_sc_reg_offset[regnum];
 263     }
 264
 265   return cache;
 266 }
 267
 268 static void
 269 m32r_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
 270                                    void **this_cache,
 271                                    struct frame_id *this_id)
 272 {
 273   struct m32r_frame_cache *cache =
 274     m32r_linux_sigtramp_frame_cache (next_frame, this_cache);
 275
 276   (*this_id) = frame_id_build (cache->base, cache->pc);
 277 }
 278
 279 static void
 280 m32r_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
 281                                          void **this_cache,
 282                                          int regnum, int *optimizedp,
 283                                          enum lval_type *lvalp,
 284                                          CORE_ADDR *addrp,
 285                                          int *realnump, gdb_byte *valuep)
 286 {
 287   struct m32r_frame_cache *cache =
 288     m32r_linux_sigtramp_frame_cache (next_frame, this_cache);
 289
 290   trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
 291                                 optimizedp, lvalp, addrp, realnump, valuep);
 292 }
 293
 294 static const struct frame_unwind m32r_linux_sigtramp_frame_unwind = {
 295   SIGTRAMP_FRAME,
 296   m32r_linux_sigtramp_frame_this_id,
 297   m32r_linux_sigtramp_frame_prev_register
 298 };
 299
 300 static const struct frame_unwind *
 301 m32r_linux_sigtramp_frame_sniffer (struct frame_info *next_frame)
 302 {
 303   CORE_ADDR pc = frame_pc_unwind (next_frame);
 304   char *name;
 305
 306   find_pc_partial_function (pc, &name, NULL, NULL);
 307   if (m32r_linux_pc_in_sigtramp (pc, name, next_frame))
 308     return &m32r_linux_sigtramp_frame_unwind;
 309
 310   return NULL;
 311 }
 312
 313 /* Mapping between the registers in `struct pt_regs'
 314    format and GDB's register array layout.  */
 315
 316 static int m32r_pt_regs_offset[] = {
 317   4 * 4,                        /* r0 */
 318   4 * 5,                        /* r1 */
 319   4 * 6,                        /* r2 */
 320   4 * 7,                        /* r3 */
 321   4 * 0,                        /* r4 */
 322   4 * 1,                        /* r5 */
 323   4 * 2,                        /* r6 */
 324   4 * 8,                        /* r7 */
 325   4 * 9,                        /* r8 */
 326   4 * 10,                       /* r9 */
 327   4 * 11,                       /* r10 */
 328   4 * 12,                       /* r11 */
 329   4 * 13,                       /* r12 */
 330   4 * 24,                       /* fp */
 331   4 * 25,                       /* lr */
 332   4 * 23,                       /* sp */
 333   4 * 19,                       /* psw */
 334   4 * 19,                       /* cbr */
 335   4 * 26,                       /* spi */
 336   4 * 23,                       /* spu */
 337   4 * 22,                       /* bpc */
 338   4 * 20,                       /* pc */
 339   4 * 16,                       /* accl */
 340   4 * 15                        /* acch */
 341 };
 342
 343 #define PSW_OFFSET (4 * 19)
 344 #define BBPSW_OFFSET (4 * 21)
 345 #define SPU_OFFSET (4 * 23)
 346 #define SPI_OFFSET (4 * 26)
 347
 348 static void
 349 m32r_linux_supply_gregset (const struct regset *regset,
 350                            struct regcache *regcache, int regnum,
 351                            const void *gregs, size_t size)
 352 {
 353   const char *regs = gregs;
 354   unsigned long psw, bbpsw;
 355   int i;
 356
 357   psw = *((unsigned long *) (regs + PSW_OFFSET));
 358   bbpsw = *((unsigned long *) (regs + BBPSW_OFFSET));
 359
 360   for (i = 0; i < sizeof (m32r_pt_regs_offset) / 4; i++)
 361     {
 362       if (regnum != -1 && regnum != i)
 363         continue;
 364
 365       switch (i)
 366         {
 367         case PSW_REGNUM:
 368           *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
 369             ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8);
 370           break;
 371         case CBR_REGNUM:
 372           *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
 373             ((psw >> 8) & 1);
 374           break;
 375         case M32R_SP_REGNUM:
 376           if (psw & 0x8000)
 377             *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
 378               *((unsigned long *) (regs + SPU_OFFSET));
 379           else
 380             *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
 381               *((unsigned long *) (regs + SPI_OFFSET));
 382           break;
 383         }
 384
 385       regcache_raw_supply (current_regcache, i,
 386                            regs + m32r_pt_regs_offset[i]);
 387     }
 388 }
 389
 390 static struct regset m32r_linux_gregset = {
 391   NULL, m32r_linux_supply_gregset
 392 };
 393
 394 static const struct regset *
 395 m32r_linux_regset_from_core_section (struct gdbarch *core_arch,
 396                                      const char *sect_name, size_t sect_size)
 397 {
 398   struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
 399   if (strcmp (sect_name, ".reg") == 0)
 400     return &m32r_linux_gregset;
 401   return NULL;
 402 }
 403
 404 static void
 405 m32r_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 406 {
 407   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 408
 409   /* Since EVB register is not available for native debug, we reduce
 410      the number of registers.  */
 411   set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);
 412
 413   frame_unwind_append_sniffer (gdbarch, m32r_linux_sigtramp_frame_sniffer);
 414
 415   /* GNU/Linux uses SVR4-style shared libraries.  */
 416   set_solib_svr4_fetch_link_map_offsets
 417     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 418
 419   /* Core file support.  */
 420   set_gdbarch_regset_from_core_section
 421     (gdbarch, m32r_linux_regset_from_core_section);
 422
 423   /* Enable TLS support.  */
 424   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 425                                              svr4_fetch_objfile_link_map);
 426 }
 427
 428 /* Provide a prototype to silence -Wmissing-prototypes.  */
 429 extern void _initialize_m32r_linux_tdep (void);
 430
 431 void
 432 _initialize_m32r_linux_tdep (void)
 433 {
 434   gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
 435                           m32r_linux_init_abi);
 436 }