gdb/m32r-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux m32r.
   2
   3    Copyright (C) 2004-2021 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   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].set_addr (sigcontext_addr
 262                                             + 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   "m32r linux sigtramp",
 306   SIGTRAMP_FRAME,
 307   default_frame_unwind_stop_reason,
 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 #define M32R_LINUX_GREGS_SIZE (4 * 28)
 350
 351 static void
 352 m32r_linux_supply_gregset (const struct regset *regset,
 353                            struct regcache *regcache, int regnum,
 354                            const void *gregs, size_t size)
 355 {
 356   const gdb_byte *regs = (const gdb_byte *) gregs;
 357   enum bfd_endian byte_order =
 358     gdbarch_byte_order (regcache->arch ());
 359   ULONGEST psw, bbpsw;
 360   gdb_byte buf[4];
 361   const gdb_byte *p;
 362   int i;
 363
 364   psw = extract_unsigned_integer (regs + PSW_OFFSET, 4, byte_order);
 365   bbpsw = extract_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order);
 366   psw = ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8);
 367
 368   for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++)
 369     {
 370       if (regnum != -1 && regnum != i)
 371         continue;
 372
 373       switch (i)
 374         {
 375         case PSW_REGNUM:
 376           store_unsigned_integer (buf, 4, byte_order, psw);
 377           p = buf;
 378           break;
 379         case CBR_REGNUM:
 380           store_unsigned_integer (buf, 4, byte_order, psw & 1);
 381           p = buf;
 382           break;
 383         case M32R_SP_REGNUM:
 384           p = regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET);
 385           break;
 386         default:
 387           p = regs + m32r_pt_regs_offset[i];
 388         }
 389
 390       regcache->raw_supply (i, p);
 391     }
 392 }
 393
 394 static void
 395 m32r_linux_collect_gregset (const struct regset *regset,
 396                             const struct regcache *regcache,
 397                             int regnum, void *gregs, size_t size)
 398 {
 399   gdb_byte *regs = (gdb_byte *) gregs;
 400   int i;
 401   enum bfd_endian byte_order =
 402     gdbarch_byte_order (regcache->arch ());
 403   ULONGEST psw;
 404   gdb_byte buf[4];
 405
 406   regcache->raw_collect (PSW_REGNUM, buf);
 407   psw = extract_unsigned_integer (buf, 4, byte_order);
 408
 409   for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++)
 410     {
 411       if (regnum != -1 && regnum != i)
 412         continue;
 413
 414       switch (i)
 415         {
 416         case PSW_REGNUM:
 417           store_unsigned_integer (regs + PSW_OFFSET, 4, byte_order,
 418                                   (psw & 0xc1) << 8);
 419           store_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order,
 420                                   (psw >> 8) & 0xc1);
 421           break;
 422         case CBR_REGNUM:
 423           break;
 424         case M32R_SP_REGNUM:
 425           regcache->raw_collect
 426             (i, regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET));
 427           break;
 428         default:
 429           regcache->raw_collect (i, regs + m32r_pt_regs_offset[i]);
 430         }
 431     }
 432 }
 433
 434 static const struct regset m32r_linux_gregset = {
 435   NULL,
 436   m32r_linux_supply_gregset, m32r_linux_collect_gregset
 437 };
 438
 439 static void
 440 m32r_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 441                                          iterate_over_regset_sections_cb *cb,
 442                                          void *cb_data,
 443                                          const struct regcache *regcache)
 444 {
 445   cb (".reg", M32R_LINUX_GREGS_SIZE, M32R_LINUX_GREGS_SIZE, &m32r_linux_gregset,
 446       NULL, cb_data);
 447 }
 448
 449 static void
 450 m32r_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 451 {
 452
 453   linux_init_abi (info, gdbarch, 0);
 454
 455   /* Since EVB register is not available for native debug, we reduce
 456      the number of registers.  */
 457   set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);
 458
 459   frame_unwind_append_unwinder (gdbarch, &m32r_linux_sigtramp_frame_unwind);
 460
 461   /* GNU/Linux uses SVR4-style shared libraries.  */
 462   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 463   set_solib_svr4_fetch_link_map_offsets
 464     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 465
 466   /* Core file support.  */
 467   set_gdbarch_iterate_over_regset_sections
 468     (gdbarch, m32r_linux_iterate_over_regset_sections);
 469
 470   /* Enable TLS support.  */
 471   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 472                                              svr4_fetch_objfile_link_map);
 473 }
 474
 475 void _initialize_m32r_linux_tdep ();
 476 void
 477 _initialize_m32r_linux_tdep ()
 478 {
 479   gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
 480                           m32r_linux_init_abi);
 481 }