gdb/m32r-linux-tdep.c

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