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 #include "linux-tdep.h"
  41
  42 \f
  43
  44 /* Recognizing signal handler frames.  */
  45
  46 /* GNU/Linux has two flavors of signals.  Normal signal handlers, and
  47    "realtime" (RT) signals.  The RT signals can provide additional
  48    information to the signal handler if the SA_SIGINFO flag is set
  49    when establishing a signal handler using `sigaction'.  It is not
  50    unlikely that future versions of GNU/Linux will support SA_SIGINFO
  51    for normal signals too.  */
  52
  53 /* When the m32r Linux kernel calls a signal handler and the
  54    SA_RESTORER flag isn't set, the return address points to a bit of
  55    code on the stack.  This function returns whether the PC appears to
  56    be within this bit of code.
  57
  58    The instruction sequence for normal signals is
  59        ldi    r7, #__NR_sigreturn
  60        trap   #2
  61    or 0x67 0x77 0x10 0xf2.
  62
  63    Checking for the code sequence should be somewhat reliable, because
  64    the effect is to call the system call sigreturn.  This is unlikely
  65    to occur anywhere other than in a signal trampoline.
  66
  67    It kind of sucks that we have to read memory from the process in
  68    order to identify a signal trampoline, but there doesn't seem to be
  69    any other way.  Therefore we only do the memory reads if no
  70    function name could be identified, which should be the case since
  71    the code is on the stack.
  72
  73    Detection of signal trampolines for handlers that set the
  74    SA_RESTORER flag is in general not possible.  Unfortunately this is
  75    what the GNU C Library has been doing for quite some time now.
  76    However, as of version 2.1.2, the GNU C Library uses signal
  77    trampolines (named __restore and __restore_rt) that are identical
  78    to the ones used by the kernel.  Therefore, these trampolines are
  79    supported too.  */
  80
  81 static const gdb_byte linux_sigtramp_code[] = {
  82   0x67, 0x77, 0x10, 0xf2,
  83 };
  84
  85 /* If PC is in a sigtramp routine, return the address of the start of
  86    the routine.  Otherwise, return 0.  */
  87
  88 static CORE_ADDR
  89 m32r_linux_sigtramp_start (CORE_ADDR pc, struct frame_info *this_frame)
  90 {
  91   gdb_byte buf[4];
  92
  93   /* We only recognize a signal trampoline if PC is at the start of
  94      one of the instructions.  We optimize for finding the PC at the
  95      start of the instruction sequence, as will be the case when the
  96      trampoline is not the first frame on the stack.  We assume that
  97      in the case where the PC is not at the start of the instruction
  98      sequence, there will be a few trailing readable bytes on the
  99      stack.  */
 100
 101   if (pc % 2 != 0)
 102     {
 103       if (!safe_frame_unwind_memory (this_frame, pc, buf, 2))
 104         return 0;
 105
 106       if (memcmp (buf, linux_sigtramp_code, 2) == 0)
 107         pc -= 2;
 108       else
 109         return 0;
 110     }
 111
 112   if (!safe_frame_unwind_memory (this_frame, pc, buf, 4))
 113     return 0;
 114
 115   if (memcmp (buf, linux_sigtramp_code, 4) != 0)
 116     return 0;
 117
 118   return pc;
 119 }
 120
 121 /* This function does the same for RT signals.  Here the instruction
 122    sequence is
 123        ldi    r7, #__NR_rt_sigreturn
 124        trap   #2
 125    or 0x97 0xf0 0x00 0xad 0x10 0xf2 0xf0 0x00.
 126
 127    The effect is to call the system call rt_sigreturn.  */
 128
 129 static const gdb_byte linux_rt_sigtramp_code[] = {
 130   0x97, 0xf0, 0x00, 0xad, 0x10, 0xf2, 0xf0, 0x00,
 131 };
 132
 133 /* If PC is in a RT sigtramp routine, return the address of the start
 134    of the routine.  Otherwise, return 0.  */
 135
 136 static CORE_ADDR
 137 m32r_linux_rt_sigtramp_start (CORE_ADDR pc, struct frame_info *this_frame)
 138 {
 139   gdb_byte buf[4];
 140
 141   /* We only recognize a signal trampoline if PC is at the start of
 142      one of the instructions.  We optimize for finding the PC at the
 143      start of the instruction sequence, as will be the case when the
 144      trampoline is not the first frame on the stack.  We assume that
 145      in the case where the PC is not at the start of the instruction
 146      sequence, there will be a few trailing readable bytes on the
 147      stack.  */
 148
 149   if (pc % 2 != 0)
 150     return 0;
 151
 152   if (!safe_frame_unwind_memory (this_frame, pc, buf, 4))
 153     return 0;
 154
 155   if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
 156     {
 157       if (!safe_frame_unwind_memory (this_frame, pc + 4, buf, 4))
 158         return 0;
 159
 160       if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0)
 161         return pc;
 162     }
 163   else if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0)
 164     {
 165       if (!safe_frame_unwind_memory (this_frame, pc - 4, buf, 4))
 166         return 0;
 167
 168       if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
 169         return pc - 4;
 170     }
 171
 172   return 0;
 173 }
 174
 175 static int
 176 m32r_linux_pc_in_sigtramp (CORE_ADDR pc, char *name,
 177                            struct frame_info *this_frame)
 178 {
 179   /* If we have NAME, we can optimize the search.  The trampolines are
 180      named __restore and __restore_rt.  However, they aren't dynamically
 181      exported from the shared C library, so the trampoline may appear to
 182      be part of the preceding function.  This should always be sigaction,
 183      __sigaction, or __libc_sigaction (all aliases to the same function).  */
 184   if (name == NULL || strstr (name, "sigaction") != NULL)
 185     return (m32r_linux_sigtramp_start (pc, this_frame) != 0
 186             || m32r_linux_rt_sigtramp_start (pc, this_frame) != 0);
 187
 188   return (strcmp ("__restore", name) == 0
 189           || strcmp ("__restore_rt", name) == 0);
 190 }
 191
 192 /* From <asm/sigcontext.h>.  */
 193 static int m32r_linux_sc_reg_offset[] = {
 194   4 * 4,                        /* r0 */
 195   5 * 4,                        /* r1 */
 196   6 * 4,                        /* r2 */
 197   7 * 4,                        /* r3 */
 198   0 * 4,                        /* r4 */
 199   1 * 4,                        /* r5 */
 200   2 * 4,                        /* r6 */
 201   8 * 4,                        /* r7 */
 202   9 * 4,                        /* r8 */
 203   10 * 4,                       /* r9 */
 204   11 * 4,                       /* r10 */
 205   12 * 4,                       /* r11 */
 206   13 * 4,                       /* r12 */
 207   21 * 4,                       /* fp */
 208   22 * 4,                       /* lr */
 209   -1 * 4,                       /* sp */
 210   16 * 4,                       /* psw */
 211   -1 * 4,                       /* cbr */
 212   23 * 4,                       /* spi */
 213   20 * 4,                       /* spu */
 214   19 * 4,                       /* bpc */
 215   17 * 4,                       /* pc */
 216   15 * 4,                       /* accl */
 217   14 * 4                        /* acch */
 218 };
 219
 220 struct m32r_frame_cache
 221 {
 222   CORE_ADDR base, pc;
 223   struct trad_frame_saved_reg *saved_regs;
 224 };
 225
 226 static struct m32r_frame_cache *
 227 m32r_linux_sigtramp_frame_cache (struct frame_info *this_frame,
 228                                  void **this_cache)
 229 {
 230   struct m32r_frame_cache *cache;
 231   CORE_ADDR sigcontext_addr, addr;
 232   int regnum;
 233
 234   if ((*this_cache) != NULL)
 235     return (*this_cache);
 236   cache = FRAME_OBSTACK_ZALLOC (struct m32r_frame_cache);
 237   (*this_cache) = cache;
 238   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 239
 240   cache->base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM);
 241   sigcontext_addr = cache->base + 4;
 242
 243   cache->pc = get_frame_pc (this_frame);
 244   addr = m32r_linux_sigtramp_start (cache->pc, this_frame);
 245   if (addr == 0)
 246     {
 247       /* If this is a RT signal trampoline, adjust SIGCONTEXT_ADDR
 248          accordingly.  */
 249       addr = m32r_linux_rt_sigtramp_start (cache->pc, this_frame);
 250       if (addr)
 251         sigcontext_addr += 128;
 252       else
 253         addr = get_frame_func (this_frame);
 254     }
 255   cache->pc = addr;
 256
 257   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 258
 259   for (regnum = 0; regnum < sizeof (m32r_linux_sc_reg_offset) / 4; regnum++)
 260     {
 261       if (m32r_linux_sc_reg_offset[regnum] >= 0)
 262         cache->saved_regs[regnum].addr =
 263           sigcontext_addr + m32r_linux_sc_reg_offset[regnum];
 264     }
 265
 266   return cache;
 267 }
 268
 269 static void
 270 m32r_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
 271                                    void **this_cache,
 272                                    struct frame_id *this_id)
 273 {
 274   struct m32r_frame_cache *cache =
 275     m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
 276
 277   (*this_id) = frame_id_build (cache->base, cache->pc);
 278 }
 279
 280 static struct value *
 281 m32r_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
 282                                          void **this_cache, int regnum)
 283 {
 284   struct m32r_frame_cache *cache =
 285     m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
 286
 287   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 288 }
 289
 290 static int
 291 m32r_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
 292                                    struct frame_info *this_frame,
 293                                    void **this_cache)
 294 {
 295   CORE_ADDR pc = get_frame_pc (this_frame);
 296   char *name;
 297
 298   find_pc_partial_function (pc, &name, NULL, NULL);
 299   if (m32r_linux_pc_in_sigtramp (pc, name, this_frame))
 300     return 1;
 301
 302   return 0;
 303 }
 304
 305 static const struct frame_unwind m32r_linux_sigtramp_frame_unwind = {
 306   SIGTRAMP_FRAME,
 307   m32r_linux_sigtramp_frame_this_id,
 308   m32r_linux_sigtramp_frame_prev_register,
 309   NULL,
 310   m32r_linux_sigtramp_frame_sniffer
 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 (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   linux_init_abi (info, gdbarch);
 410
 411   /* Since EVB register is not available for native debug, we reduce
 412      the number of registers.  */
 413   set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);
 414
 415   frame_unwind_append_unwinder (gdbarch, &m32r_linux_sigtramp_frame_unwind);
 416
 417   /* GNU/Linux uses SVR4-style shared libraries.  */
 418   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 419   set_solib_svr4_fetch_link_map_offsets
 420     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 421
 422   /* Core file support.  */
 423   set_gdbarch_regset_from_core_section
 424     (gdbarch, m32r_linux_regset_from_core_section);
 425
 426   /* Enable TLS support.  */
 427   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 428                                              svr4_fetch_objfile_link_map);
 429 }
 430
 431 /* Provide a prototype to silence -Wmissing-prototypes.  */
 432 extern void _initialize_m32r_linux_tdep (void);
 433
 434 void
 435 _initialize_m32r_linux_tdep (void)
 436 {
 437   gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
 438                           m32r_linux_init_abi);
 439 }