gdb/m32r-linux-tdep.c

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