gdb/alpha-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux on Alpha.
   2    Copyright (C) 2002-2018 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "defs.h"
  20 #include "frame.h"
  21 #include "osabi.h"
  22 #include "solib-svr4.h"
  23 #include "symtab.h"
  24 #include "regset.h"
  25 #include "regcache.h"
  26 #include "linux-tdep.h"
  27 #include "alpha-tdep.h"
  28
  29 /* This enum represents the signals' numbers on the Alpha
  30    architecture.  It just contains the signal definitions which are
  31    different from the generic implementation.
  32
  33    It is derived from the file <arch/alpha/include/uapi/asm/signal.h>,
  34    from the Linux kernel tree.  */
  35
  36 enum
  37   {
  38     /* SIGABRT is the same as in the generic implementation, but is
  39        defined here because SIGIOT depends on it.  */
  40     ALPHA_LINUX_SIGABRT = 6,
  41     ALPHA_LINUX_SIGEMT = 7,
  42     ALPHA_LINUX_SIGBUS = 10,
  43     ALPHA_LINUX_SIGSYS = 12,
  44     ALPHA_LINUX_SIGURG = 16,
  45     ALPHA_LINUX_SIGSTOP = 17,
  46     ALPHA_LINUX_SIGTSTP = 18,
  47     ALPHA_LINUX_SIGCONT = 19,
  48     ALPHA_LINUX_SIGCHLD = 20,
  49     ALPHA_LINUX_SIGIO = 23,
  50     ALPHA_LINUX_SIGINFO = 29,
  51     ALPHA_LINUX_SIGUSR1 = 30,
  52     ALPHA_LINUX_SIGUSR2 = 31,
  53     ALPHA_LINUX_SIGPOLL = ALPHA_LINUX_SIGIO,
  54     ALPHA_LINUX_SIGPWR = ALPHA_LINUX_SIGINFO,
  55     ALPHA_LINUX_SIGIOT = ALPHA_LINUX_SIGABRT,
  56   };
  57
  58 /* Under GNU/Linux, signal handler invocations can be identified by
  59    the designated code sequence that is used to return from a signal
  60    handler.  In particular, the return address of a signal handler
  61    points to a sequence that copies $sp to $16, loads $0 with the
  62    appropriate syscall number, and finally enters the kernel.
  63
  64    This is somewhat complicated in that:
  65      (1) the expansion of the "mov" assembler macro has changed over
  66          time, from "bis src,src,dst" to "bis zero,src,dst",
  67      (2) the kernel has changed from using "addq" to "lda" to load the
  68          syscall number,
  69      (3) there is a "normal" sigreturn and an "rt" sigreturn which
  70          has a different stack layout.  */
  71
  72 static long
  73 alpha_linux_sigtramp_offset_1 (struct gdbarch *gdbarch, CORE_ADDR pc)
  74 {
  75   switch (alpha_read_insn (gdbarch, pc))
  76     {
  77     case 0x47de0410:            /* bis $30,$30,$16 */
  78     case 0x47fe0410:            /* bis $31,$30,$16 */
  79       return 0;
  80
  81     case 0x43ecf400:            /* addq $31,103,$0 */
  82     case 0x201f0067:            /* lda $0,103($31) */
  83     case 0x201f015f:            /* lda $0,351($31) */
  84       return 4;
  85
  86     case 0x00000083:            /* call_pal callsys */
  87       return 8;
  88
  89     default:
  90       return -1;
  91     }
  92 }
  93
  94 static LONGEST
  95 alpha_linux_sigtramp_offset (struct gdbarch *gdbarch, CORE_ADDR pc)
  96 {
  97   long i, off;
  98
  99   if (pc & 3)
 100     return -1;
 101
 102   /* Guess where we might be in the sequence.  */
 103   off = alpha_linux_sigtramp_offset_1 (gdbarch, pc);
 104   if (off < 0)
 105     return -1;
 106
 107   /* Verify that the other two insns of the sequence are as we expect.  */
 108   pc -= off;
 109   for (i = 0; i < 12; i += 4)
 110     {
 111       if (i == off)
 112         continue;
 113       if (alpha_linux_sigtramp_offset_1 (gdbarch, pc + i) != i)
 114         return -1;
 115     }
 116
 117   return off;
 118 }
 119
 120 static int
 121 alpha_linux_pc_in_sigtramp (struct gdbarch *gdbarch,
 122                             CORE_ADDR pc, const char *func_name)
 123 {
 124   return alpha_linux_sigtramp_offset (gdbarch, pc) >= 0;
 125 }
 126
 127 static CORE_ADDR
 128 alpha_linux_sigcontext_addr (struct frame_info *this_frame)
 129 {
 130   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 131   CORE_ADDR pc;
 132   ULONGEST sp;
 133   long off;
 134
 135   pc = get_frame_pc (this_frame);
 136   sp = get_frame_register_unsigned (this_frame, ALPHA_SP_REGNUM);
 137
 138   off = alpha_linux_sigtramp_offset (gdbarch, pc);
 139   gdb_assert (off >= 0);
 140
 141   /* __NR_rt_sigreturn has a couple of structures on the stack.  This is:
 142
 143         struct rt_sigframe {
 144           struct siginfo info;
 145           struct ucontext uc;
 146         };
 147
 148         offsetof (struct rt_sigframe, uc.uc_mcontext);  */
 149
 150   if (alpha_read_insn (gdbarch, pc - off + 4) == 0x201f015f)
 151     return sp + 176;
 152
 153   /* __NR_sigreturn has the sigcontext structure at the top of the stack.  */
 154   return sp;
 155 }
 156
 157 /* Supply register REGNUM from the buffer specified by GREGS and LEN
 158    in the general-purpose register set REGSET to register cache
 159    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 160
 161 static void
 162 alpha_linux_supply_gregset (const struct regset *regset,
 163                             struct regcache *regcache,
 164                             int regnum, const void *gregs, size_t len)
 165 {
 166   const gdb_byte *regs = (const gdb_byte *) gregs;
 167
 168   gdb_assert (len >= 32 * 8);
 169   alpha_supply_int_regs (regcache, regnum, regs, regs + 31 * 8,
 170                          len >= 33 * 8 ? regs + 32 * 8 : NULL);
 171 }
 172
 173 /* Collect register REGNUM from the register cache REGCACHE and store
 174    it in the buffer specified by GREGS and LEN as described by the
 175    general-purpose register set REGSET.  If REGNUM is -1, do this for
 176    all registers in REGSET.  */
 177
 178 static void
 179 alpha_linux_collect_gregset (const struct regset *regset,
 180                              const struct regcache *regcache,
 181                              int regnum, void *gregs, size_t len)
 182 {
 183   gdb_byte *regs = (gdb_byte *) gregs;
 184
 185   gdb_assert (len >= 32 * 8);
 186   alpha_fill_int_regs (regcache, regnum, regs, regs + 31 * 8,
 187                        len >= 33 * 8 ? regs + 32 * 8 : NULL);
 188 }
 189
 190 /* Supply register REGNUM from the buffer specified by FPREGS and LEN
 191    in the floating-point register set REGSET to register cache
 192    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 193
 194 static void
 195 alpha_linux_supply_fpregset (const struct regset *regset,
 196                              struct regcache *regcache,
 197                              int regnum, const void *fpregs, size_t len)
 198 {
 199   const gdb_byte *regs = (const gdb_byte *) fpregs;
 200
 201   gdb_assert (len >= 32 * 8);
 202   alpha_supply_fp_regs (regcache, regnum, regs, regs + 31 * 8);
 203 }
 204
 205 /* Collect register REGNUM from the register cache REGCACHE and store
 206    it in the buffer specified by FPREGS and LEN as described by the
 207    general-purpose register set REGSET.  If REGNUM is -1, do this for
 208    all registers in REGSET.  */
 209
 210 static void
 211 alpha_linux_collect_fpregset (const struct regset *regset,
 212                               const struct regcache *regcache,
 213                               int regnum, void *fpregs, size_t len)
 214 {
 215   gdb_byte *regs = (gdb_byte *) fpregs;
 216
 217   gdb_assert (len >= 32 * 8);
 218   alpha_fill_fp_regs (regcache, regnum, regs, regs + 31 * 8);
 219 }
 220
 221 static const struct regset alpha_linux_gregset =
 222 {
 223   NULL,
 224   alpha_linux_supply_gregset, alpha_linux_collect_gregset
 225 };
 226
 227 static const struct regset alpha_linux_fpregset =
 228 {
 229   NULL,
 230   alpha_linux_supply_fpregset, alpha_linux_collect_fpregset
 231 };
 232
 233 /* Iterate over core file register note sections.  */
 234
 235 static void
 236 alpha_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 237                                           iterate_over_regset_sections_cb *cb,
 238                                           void *cb_data,
 239                                           const struct regcache *regcache)
 240 {
 241   cb (".reg", 32 * 8, 32 * 8, &alpha_linux_gregset, NULL, cb_data);
 242   cb (".reg2", 32 * 8, 32 * 8, &alpha_linux_fpregset, NULL, cb_data);
 243 }
 244
 245 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
 246    gdbarch.h.  */
 247
 248 static enum gdb_signal
 249 alpha_linux_gdb_signal_from_target (struct gdbarch *gdbarch,
 250                                     int signal)
 251 {
 252   switch (signal)
 253     {
 254     case ALPHA_LINUX_SIGEMT:
 255       return GDB_SIGNAL_EMT;
 256
 257     case ALPHA_LINUX_SIGBUS:
 258       return GDB_SIGNAL_BUS;
 259
 260     case ALPHA_LINUX_SIGSYS:
 261       return GDB_SIGNAL_SYS;
 262
 263     case ALPHA_LINUX_SIGURG:
 264       return GDB_SIGNAL_URG;
 265
 266     case ALPHA_LINUX_SIGSTOP:
 267       return GDB_SIGNAL_STOP;
 268
 269     case ALPHA_LINUX_SIGTSTP:
 270       return GDB_SIGNAL_TSTP;
 271
 272     case ALPHA_LINUX_SIGCONT:
 273       return GDB_SIGNAL_CONT;
 274
 275     case ALPHA_LINUX_SIGCHLD:
 276       return GDB_SIGNAL_CHLD;
 277
 278     /* No way to differentiate between SIGIO and SIGPOLL.
 279        Therefore, we just handle the first one.  */
 280     case ALPHA_LINUX_SIGIO:
 281       return GDB_SIGNAL_IO;
 282
 283     /* No way to differentiate between SIGINFO and SIGPWR.
 284        Therefore, we just handle the first one.  */
 285     case ALPHA_LINUX_SIGINFO:
 286       return GDB_SIGNAL_INFO;
 287
 288     case ALPHA_LINUX_SIGUSR1:
 289       return GDB_SIGNAL_USR1;
 290
 291     case ALPHA_LINUX_SIGUSR2:
 292       return GDB_SIGNAL_USR2;
 293     }
 294
 295   return linux_gdb_signal_from_target (gdbarch, signal);
 296 }
 297
 298 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
 299    gdbarch.h.  */
 300
 301 static int
 302 alpha_linux_gdb_signal_to_target (struct gdbarch *gdbarch,
 303                                   enum gdb_signal signal)
 304 {
 305   switch (signal)
 306     {
 307     case GDB_SIGNAL_EMT:
 308       return ALPHA_LINUX_SIGEMT;
 309
 310     case GDB_SIGNAL_BUS:
 311       return ALPHA_LINUX_SIGBUS;
 312
 313     case GDB_SIGNAL_SYS:
 314       return ALPHA_LINUX_SIGSYS;
 315
 316     case GDB_SIGNAL_URG:
 317       return ALPHA_LINUX_SIGURG;
 318
 319     case GDB_SIGNAL_STOP:
 320       return ALPHA_LINUX_SIGSTOP;
 321
 322     case GDB_SIGNAL_TSTP:
 323       return ALPHA_LINUX_SIGTSTP;
 324
 325     case GDB_SIGNAL_CONT:
 326       return ALPHA_LINUX_SIGCONT;
 327
 328     case GDB_SIGNAL_CHLD:
 329       return ALPHA_LINUX_SIGCHLD;
 330
 331     case GDB_SIGNAL_IO:
 332       return ALPHA_LINUX_SIGIO;
 333
 334     case GDB_SIGNAL_INFO:
 335       return ALPHA_LINUX_SIGINFO;
 336
 337     case GDB_SIGNAL_USR1:
 338       return ALPHA_LINUX_SIGUSR1;
 339
 340     case GDB_SIGNAL_USR2:
 341       return ALPHA_LINUX_SIGUSR2;
 342
 343     case GDB_SIGNAL_POLL:
 344       return ALPHA_LINUX_SIGPOLL;
 345
 346     case GDB_SIGNAL_PWR:
 347       return ALPHA_LINUX_SIGPWR;
 348     }
 349
 350   return linux_gdb_signal_to_target (gdbarch, signal);
 351 }
 352
 353 static void
 354 alpha_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 355 {
 356   struct gdbarch_tdep *tdep;
 357
 358   linux_init_abi (info, gdbarch);
 359
 360   /* Hook into the DWARF CFI frame unwinder.  */
 361   alpha_dwarf2_init_abi (info, gdbarch);
 362
 363   /* Hook into the MDEBUG frame unwinder.  */
 364   alpha_mdebug_init_abi (info, gdbarch);
 365
 366   tdep = gdbarch_tdep (gdbarch);
 367   tdep->dynamic_sigtramp_offset = alpha_linux_sigtramp_offset;
 368   tdep->sigcontext_addr = alpha_linux_sigcontext_addr;
 369   tdep->pc_in_sigtramp = alpha_linux_pc_in_sigtramp;
 370   tdep->jb_pc = 2;
 371   tdep->jb_elt_size = 8;
 372
 373   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 374
 375   set_solib_svr4_fetch_link_map_offsets
 376     (gdbarch, svr4_lp64_fetch_link_map_offsets);
 377
 378   /* Enable TLS support.  */
 379   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 380                                              svr4_fetch_objfile_link_map);
 381
 382   set_gdbarch_iterate_over_regset_sections
 383     (gdbarch, alpha_linux_iterate_over_regset_sections);
 384
 385   set_gdbarch_gdb_signal_from_target (gdbarch,
 386                                       alpha_linux_gdb_signal_from_target);
 387   set_gdbarch_gdb_signal_to_target (gdbarch,
 388                                     alpha_linux_gdb_signal_to_target);
 389 }
 390
 391 void
 392 _initialize_alpha_linux_tdep (void)
 393 {
 394   gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_LINUX,
 395                           alpha_linux_init_abi);
 396 }