gdb/m32r-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux m32r.
   2
   3    Copyright (C) 2004-2020 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 "glibc-tdep.h"
  31 #include "solib-svr4.h"
  32 #include "symtab.h"
  33
  34 #include "trad-frame.h"
  35 #include "frame-unwind.h"
  36
  37 #include "m32r-tdep.h"
  38 #include "linux-tdep.h"
  39 #include "gdbarch.h"
  40
  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 *this_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 (this_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 (this_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 *this_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 (this_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 (this_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 (this_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, const char *name,
 176                            struct frame_info *this_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, this_frame) != 0
 185             || m32r_linux_rt_sigtramp_start (pc, this_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 *this_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 (struct m32r_frame_cache *) (*this_cache);
 235   cache = FRAME_OBSTACK_ZALLOC (struct m32r_frame_cache);
 236   (*this_cache) = cache;
 237   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 238
 239   cache->base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM);
 240   sigcontext_addr = cache->base + 4;
 241
 242   cache->pc = get_frame_pc (this_frame);
 243   addr = m32r_linux_sigtramp_start (cache->pc, this_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, this_frame);
 249       if (addr)
 250         sigcontext_addr += 128;
 251       else
 252         addr = get_frame_func (this_frame);
 253     }
 254   cache->pc = addr;
 255
 256   cache->saved_regs = trad_frame_alloc_saved_regs (this_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 *this_frame,
 270                                    void **this_cache,
 271                                    struct frame_id *this_id)
 272 {
 273   struct m32r_frame_cache *cache =
 274     m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
 275
 276   (*this_id) = frame_id_build (cache->base, cache->pc);
 277 }
 278
 279 static struct value *
 280 m32r_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
 281                                          void **this_cache, int regnum)
 282 {
 283   struct m32r_frame_cache *cache =
 284     m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
 285
 286   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 287 }
 288
 289 static int
 290 m32r_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
 291                                    struct frame_info *this_frame,
 292                                    void **this_cache)
 293 {
 294   CORE_ADDR pc = get_frame_pc (this_frame);
 295   const char *name;
 296
 297   find_pc_partial_function (pc, &name, NULL, NULL);
 298   if (m32r_linux_pc_in_sigtramp (pc, name, this_frame))
 299     return 1;
 300
 301   return 0;
 302 }
 303
 304 static const struct frame_unwind m32r_linux_sigtramp_frame_unwind = {
 305   SIGTRAMP_FRAME,
 306   default_frame_unwind_stop_reason,
 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 #define M32R_LINUX_GREGS_SIZE (4 * 28)
 349
 350 static void
 351 m32r_linux_supply_gregset (const struct regset *regset,
 352                            struct regcache *regcache, int regnum,
 353                            const void *gregs, size_t size)
 354 {
 355   const gdb_byte *regs = (const gdb_byte *) gregs;
 356   enum bfd_endian byte_order =
 357     gdbarch_byte_order (regcache->arch ());
 358   ULONGEST psw, bbpsw;
 359   gdb_byte buf[4];
 360   const gdb_byte *p;
 361   int i;
 362
 363   psw = extract_unsigned_integer (regs + PSW_OFFSET, 4, byte_order);
 364   bbpsw = extract_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order);
 365   psw = ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8);
 366
 367   for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++)
 368     {
 369       if (regnum != -1 && regnum != i)
 370         continue;
 371
 372       switch (i)
 373         {
 374         case PSW_REGNUM:
 375           store_unsigned_integer (buf, 4, byte_order, psw);
 376           p = buf;
 377           break;
 378         case CBR_REGNUM:
 379           store_unsigned_integer (buf, 4, byte_order, psw & 1);
 380           p = buf;
 381           break;
 382         case M32R_SP_REGNUM:
 383           p = regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET);
 384           break;
 385         default:
 386           p = regs + m32r_pt_regs_offset[i];
 387         }
 388
 389       regcache->raw_supply (i, p);
 390     }
 391 }
 392
 393 static void
 394 m32r_linux_collect_gregset (const struct regset *regset,
 395                             const struct regcache *regcache,
 396                             int regnum, void *gregs, size_t size)
 397 {
 398   gdb_byte *regs = (gdb_byte *) gregs;
 399   int i;
 400   enum bfd_endian byte_order =
 401     gdbarch_byte_order (regcache->arch ());
 402   ULONGEST psw;
 403   gdb_byte buf[4];
 404
 405   regcache->raw_collect (PSW_REGNUM, buf);
 406   psw = extract_unsigned_integer (buf, 4, byte_order);
 407
 408   for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++)
 409     {
 410       if (regnum != -1 && regnum != i)
 411         continue;
 412
 413       switch (i)
 414         {
 415         case PSW_REGNUM:
 416           store_unsigned_integer (regs + PSW_OFFSET, 4, byte_order,
 417                                   (psw & 0xc1) << 8);
 418           store_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order,
 419                                   (psw >> 8) & 0xc1);
 420           break;
 421         case CBR_REGNUM:
 422           break;
 423         case M32R_SP_REGNUM:
 424           regcache->raw_collect
 425             (i, regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET));
 426           break;
 427         default:
 428           regcache->raw_collect (i, regs + m32r_pt_regs_offset[i]);
 429         }
 430     }
 431 }
 432
 433 static const struct regset m32r_linux_gregset = {
 434   NULL,
 435   m32r_linux_supply_gregset, m32r_linux_collect_gregset
 436 };
 437
 438 static void
 439 m32r_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 440                                          iterate_over_regset_sections_cb *cb,
 441                                          void *cb_data,
 442                                          const struct regcache *regcache)
 443 {
 444   cb (".reg", M32R_LINUX_GREGS_SIZE, M32R_LINUX_GREGS_SIZE, &m32r_linux_gregset,
 445       NULL, cb_data);
 446 }
 447
 448 static void
 449 m32r_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 450 {
 451
 452   linux_init_abi (info, gdbarch);
 453
 454   /* Since EVB register is not available for native debug, we reduce
 455      the number of registers.  */
 456   set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);
 457
 458   frame_unwind_append_unwinder (gdbarch, &m32r_linux_sigtramp_frame_unwind);
 459
 460   /* GNU/Linux uses SVR4-style shared libraries.  */
 461   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 462   set_solib_svr4_fetch_link_map_offsets
 463     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 464
 465   /* Core file support.  */
 466   set_gdbarch_iterate_over_regset_sections
 467     (gdbarch, m32r_linux_iterate_over_regset_sections);
 468
 469   /* Enable TLS support.  */
 470   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 471                                              svr4_fetch_objfile_link_map);
 472 }
 473
 474 void _initialize_m32r_linux_tdep ();
 475 void
 476 _initialize_m32r_linux_tdep ()
 477 {
 478   gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
 479                           m32r_linux_init_abi);
 480 }