gdb/alpha-linux-tdep.c

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