gdb/m32r-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux m32r.
   2
   3    Copyright (C) 2004, 2007, 2008, 2009, 2010 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 *this_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 (this_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 (this_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 *this_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 (this_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 (this_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 (this_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 *this_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, this_frame) != 0
 184             || m32r_linux_rt_sigtramp_start (pc, this_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 *this_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 (this_frame);
 237
 238   cache->base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM);
 239   sigcontext_addr = cache->base + 4;
 240
 241   cache->pc = get_frame_pc (this_frame);
 242   addr = m32r_linux_sigtramp_start (cache->pc, this_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, this_frame);
 248       if (addr)
 249         sigcontext_addr += 128;
 250       else
 251         addr = get_frame_func (this_frame);
 252     }
 253   cache->pc = addr;
 254
 255   cache->saved_regs = trad_frame_alloc_saved_regs (this_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 *this_frame,
 269                                    void **this_cache,
 270                                    struct frame_id *this_id)
 271 {
 272   struct m32r_frame_cache *cache =
 273     m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
 274
 275   (*this_id) = frame_id_build (cache->base, cache->pc);
 276 }
 277
 278 static struct value *
 279 m32r_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
 280                                          void **this_cache, int regnum)
 281 {
 282   struct m32r_frame_cache *cache =
 283     m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
 284
 285   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 286 }
 287
 288 static int
 289 m32r_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
 290                                    struct frame_info *this_frame,
 291                                    void **this_cache)
 292 {
 293   CORE_ADDR pc = get_frame_pc (this_frame);
 294   char *name;
 295
 296   find_pc_partial_function (pc, &name, NULL, NULL);
 297   if (m32r_linux_pc_in_sigtramp (pc, name, this_frame))
 298     return 1;
 299
 300   return 0;
 301 }
 302
 303 static const struct frame_unwind m32r_linux_sigtramp_frame_unwind = {
 304   SIGTRAMP_FRAME,
 305   m32r_linux_sigtramp_frame_this_id,
 306   m32r_linux_sigtramp_frame_prev_register,
 307   NULL,
 308   m32r_linux_sigtramp_frame_sniffer
 309 };
 310
 311 /* Mapping between the registers in `struct pt_regs'
 312    format and GDB's register array layout.  */
 313
 314 static int m32r_pt_regs_offset[] = {
 315   4 * 4,                        /* r0 */
 316   4 * 5,                        /* r1 */
 317   4 * 6,                        /* r2 */
 318   4 * 7,                        /* r3 */
 319   4 * 0,                        /* r4 */
 320   4 * 1,                        /* r5 */
 321   4 * 2,                        /* r6 */
 322   4 * 8,                        /* r7 */
 323   4 * 9,                        /* r8 */
 324   4 * 10,                       /* r9 */
 325   4 * 11,                       /* r10 */
 326   4 * 12,                       /* r11 */
 327   4 * 13,                       /* r12 */
 328   4 * 24,                       /* fp */
 329   4 * 25,                       /* lr */
 330   4 * 23,                       /* sp */
 331   4 * 19,                       /* psw */
 332   4 * 19,                       /* cbr */
 333   4 * 26,                       /* spi */
 334   4 * 23,                       /* spu */
 335   4 * 22,                       /* bpc */
 336   4 * 20,                       /* pc */
 337   4 * 16,                       /* accl */
 338   4 * 15                        /* acch */
 339 };
 340
 341 #define PSW_OFFSET (4 * 19)
 342 #define BBPSW_OFFSET (4 * 21)
 343 #define SPU_OFFSET (4 * 23)
 344 #define SPI_OFFSET (4 * 26)
 345
 346 static void
 347 m32r_linux_supply_gregset (const struct regset *regset,
 348                            struct regcache *regcache, int regnum,
 349                            const void *gregs, size_t size)
 350 {
 351   const char *regs = gregs;
 352   unsigned long psw, bbpsw;
 353   int i;
 354
 355   psw = *((unsigned long *) (regs + PSW_OFFSET));
 356   bbpsw = *((unsigned long *) (regs + BBPSW_OFFSET));
 357
 358   for (i = 0; i < sizeof (m32r_pt_regs_offset) / 4; i++)
 359     {
 360       if (regnum != -1 && regnum != i)
 361         continue;
 362
 363       switch (i)
 364         {
 365         case PSW_REGNUM:
 366           *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
 367             ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8);
 368           break;
 369         case CBR_REGNUM:
 370           *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
 371             ((psw >> 8) & 1);
 372           break;
 373         case M32R_SP_REGNUM:
 374           if (psw & 0x8000)
 375             *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
 376               *((unsigned long *) (regs + SPU_OFFSET));
 377           else
 378             *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
 379               *((unsigned long *) (regs + SPI_OFFSET));
 380           break;
 381         }
 382
 383       regcache_raw_supply (regcache, i,
 384                            regs + m32r_pt_regs_offset[i]);
 385     }
 386 }
 387
 388 static struct regset m32r_linux_gregset = {
 389   NULL, m32r_linux_supply_gregset
 390 };
 391
 392 static const struct regset *
 393 m32r_linux_regset_from_core_section (struct gdbarch *core_arch,
 394                                      const char *sect_name, size_t sect_size)
 395 {
 396   struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
 397   if (strcmp (sect_name, ".reg") == 0)
 398     return &m32r_linux_gregset;
 399   return NULL;
 400 }
 401
 402 static void
 403 m32r_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 404 {
 405   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 406
 407   /* Since EVB register is not available for native debug, we reduce
 408      the number of registers.  */
 409   set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);
 410
 411   frame_unwind_append_unwinder (gdbarch, &m32r_linux_sigtramp_frame_unwind);
 412
 413   /* GNU/Linux uses SVR4-style shared libraries.  */
 414   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 415   set_solib_svr4_fetch_link_map_offsets
 416     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 417
 418   /* Core file support.  */
 419   set_gdbarch_regset_from_core_section
 420     (gdbarch, m32r_linux_regset_from_core_section);
 421
 422   /* Enable TLS support.  */
 423   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 424                                              svr4_fetch_objfile_link_map);
 425 }
 426
 427 /* Provide a prototype to silence -Wmissing-prototypes.  */
 428 extern void _initialize_m32r_linux_tdep (void);
 429
 430 void
 431 _initialize_m32r_linux_tdep (void)
 432 {
 433   gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
 434                           m32r_linux_init_abi);
 435 }