gdb/sparc-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux SPARC.
   2
   3    Copyright (C) 2003-2014 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 "dwarf2-frame.h"
  22 #include "frame.h"
  23 #include "frame-unwind.h"
  24 #include "gdbtypes.h"
  25 #include "regset.h"
  26 #include "gdbarch.h"
  27 #include "gdbcore.h"
  28 #include "osabi.h"
  29 #include "regcache.h"
  30 #include "solib-svr4.h"
  31 #include "symtab.h"
  32 #include "trad-frame.h"
  33 #include "tramp-frame.h"
  34 #include "xml-syscall.h"
  35 #include "linux-tdep.h"
  36
  37 /* The syscall's XML filename for sparc 32-bit.  */
  38 #define XML_SYSCALL_FILENAME_SPARC32 "syscalls/sparc-linux.xml"
  39
  40 #include "sparc-tdep.h"
  41
  42 /* Signal trampoline support.  */
  43
  44 static void sparc32_linux_sigframe_init (const struct tramp_frame *self,
  45                                          struct frame_info *this_frame,
  46                                          struct trad_frame_cache *this_cache,
  47                                          CORE_ADDR func);
  48
  49 /* GNU/Linux has two flavors of signals.  Normal signal handlers, and
  50    "realtime" (RT) signals.  The RT signals can provide additional
  51    information to the signal handler if the SA_SIGINFO flag is set
  52    when establishing a signal handler using `sigaction'.  It is not
  53    unlikely that future versions of GNU/Linux will support SA_SIGINFO
  54    for normal signals too.  */
  55
  56 /* When the sparc Linux kernel calls a signal handler and the
  57    SA_RESTORER flag isn't set, the return address points to a bit of
  58    code on the stack.  This code checks whether the PC appears to be
  59    within this bit of code.
  60
  61    The instruction sequence for normal signals is encoded below.
  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 a signal trampoline.  */
  65
  66 static const struct tramp_frame sparc32_linux_sigframe =
  67 {
  68   SIGTRAMP_FRAME,
  69   4,
  70   {
  71     { 0x821020d8, -1 },         /* mov __NR_sugreturn, %g1 */
  72     { 0x91d02010, -1 },         /* ta  0x10 */
  73     { TRAMP_SENTINEL_INSN, -1 }
  74   },
  75   sparc32_linux_sigframe_init
  76 };
  77
  78 /* The instruction sequence for RT signals is slightly different.  The
  79    effect is to call the system call rt_sigreturn.  */
  80
  81 static const struct tramp_frame sparc32_linux_rt_sigframe =
  82 {
  83   SIGTRAMP_FRAME,
  84   4,
  85   {
  86     { 0x82102065, -1 },         /* mov __NR_rt_sigreturn, %g1 */
  87     { 0x91d02010, -1 },         /* ta  0x10 */
  88     { TRAMP_SENTINEL_INSN, -1 }
  89   },
  90   sparc32_linux_sigframe_init
  91 };
  92
  93 /* This enum represents the signals' numbers on the SPARC
  94    architecture.  It just contains the signal definitions which are
  95    different from the generic implementation.
  96
  97    It is derived from the file <arch/sparc/include/uapi/asm/signal.h>,
  98    from the Linux kernel tree.  */
  99
 100 enum
 101   {
 102     SPARC_LINUX_SIGEMT = 7,
 103     SPARC_LINUX_SIGBUS = 10,
 104     SPARC_LINUX_SIGSYS = 12,
 105     SPARC_LINUX_SIGURG = 16,
 106     SPARC_LINUX_SIGSTOP = 17,
 107     SPARC_LINUX_SIGTSTP = 18,
 108     SPARC_LINUX_SIGCONT = 19,
 109     SPARC_LINUX_SIGCHLD = 20,
 110     SPARC_LINUX_SIGIO = 23,
 111     SPARC_LINUX_SIGPOLL = SPARC_LINUX_SIGIO,
 112     SPARC_LINUX_SIGLOST = 29,
 113     SPARC_LINUX_SIGPWR = SPARC_LINUX_SIGLOST,
 114     SPARC_LINUX_SIGUSR1 = 30,
 115     SPARC_LINUX_SIGUSR2 = 31,
 116   };
 117
 118 static void
 119 sparc32_linux_sigframe_init (const struct tramp_frame *self,
 120                              struct frame_info *this_frame,
 121                              struct trad_frame_cache *this_cache,
 122                              CORE_ADDR func)
 123 {
 124   CORE_ADDR base, addr, sp_addr;
 125   int regnum;
 126
 127   base = get_frame_register_unsigned (this_frame, SPARC_O1_REGNUM);
 128   if (self == &sparc32_linux_rt_sigframe)
 129     base += 128;
 130
 131   /* Offsets from <bits/sigcontext.h>.  */
 132
 133   trad_frame_set_reg_addr (this_cache, SPARC32_PSR_REGNUM, base + 0);
 134   trad_frame_set_reg_addr (this_cache, SPARC32_PC_REGNUM, base + 4);
 135   trad_frame_set_reg_addr (this_cache, SPARC32_NPC_REGNUM, base + 8);
 136   trad_frame_set_reg_addr (this_cache, SPARC32_Y_REGNUM, base + 12);
 137
 138   /* Since %g0 is always zero, keep the identity encoding.  */
 139   addr = base + 20;
 140   sp_addr = base + 16 + ((SPARC_SP_REGNUM - SPARC_G0_REGNUM) * 4);
 141   for (regnum = SPARC_G1_REGNUM; regnum <= SPARC_O7_REGNUM; regnum++)
 142     {
 143       trad_frame_set_reg_addr (this_cache, regnum, addr);
 144       addr += 4;
 145     }
 146
 147   base = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
 148   addr = get_frame_memory_unsigned (this_frame, sp_addr, 4);
 149
 150   for (regnum = SPARC_L0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
 151     {
 152       trad_frame_set_reg_addr (this_cache, regnum, addr);
 153       addr += 4;
 154     }
 155   trad_frame_set_id (this_cache, frame_id_build (base, func));
 156 }
 157 \f
 158 /* Return the address of a system call's alternative return
 159    address.  */
 160
 161 static CORE_ADDR
 162 sparc32_linux_step_trap (struct frame_info *frame, unsigned long insn)
 163 {
 164   if (insn == 0x91d02010)
 165     {
 166       ULONGEST sc_num = get_frame_register_unsigned (frame, SPARC_G1_REGNUM);
 167
 168       /* __NR_rt_sigreturn is 101 and __NR_sigreturn is 216.  */
 169       if (sc_num == 101 || sc_num == 216)
 170         {
 171           struct gdbarch *gdbarch = get_frame_arch (frame);
 172           enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 173
 174           ULONGEST sp, pc_offset;
 175
 176           sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
 177
 178           /* The kernel puts the sigreturn registers on the stack,
 179              and this is where the signal unwinding state is take from
 180              when returning from a signal.
 181
 182              For __NR_sigreturn, this register area sits 96 bytes from
 183              the base of the stack.  The saved PC sits 4 bytes into the
 184              sigreturn register save area.
 185
 186              For __NR_rt_sigreturn a siginfo_t, which is 128 bytes, sits
 187              right before the sigreturn register save area.  */
 188
 189           pc_offset = 96 + 4;
 190           if (sc_num == 101)
 191             pc_offset += 128;
 192
 193           return read_memory_unsigned_integer (sp + pc_offset, 4, byte_order);
 194         }
 195     }
 196
 197   return 0;
 198 }
 199 \f
 200
 201 const struct sparc_gregmap sparc32_linux_core_gregmap =
 202 {
 203   32 * 4,                       /* %psr */
 204   33 * 4,                       /* %pc */
 205   34 * 4,                       /* %npc */
 206   35 * 4,                       /* %y */
 207   -1,                           /* %wim */
 208   -1,                           /* %tbr */
 209   1 * 4,                        /* %g1 */
 210   16 * 4,                       /* %l0 */
 211   4,                            /* y size */
 212 };
 213 \f
 214
 215 static void
 216 sparc32_linux_supply_core_gregset (const struct regset *regset,
 217                                    struct regcache *regcache,
 218                                    int regnum, const void *gregs, size_t len)
 219 {
 220   sparc32_supply_gregset (&sparc32_linux_core_gregmap,
 221                           regcache, regnum, gregs);
 222 }
 223
 224 static void
 225 sparc32_linux_collect_core_gregset (const struct regset *regset,
 226                                     const struct regcache *regcache,
 227                                     int regnum, void *gregs, size_t len)
 228 {
 229   sparc32_collect_gregset (&sparc32_linux_core_gregmap,
 230                            regcache, regnum, gregs);
 231 }
 232
 233 static void
 234 sparc32_linux_supply_core_fpregset (const struct regset *regset,
 235                                     struct regcache *regcache,
 236                                     int regnum, const void *fpregs, size_t len)
 237 {
 238   sparc32_supply_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
 239 }
 240
 241 static void
 242 sparc32_linux_collect_core_fpregset (const struct regset *regset,
 243                                      const struct regcache *regcache,
 244                                      int regnum, void *fpregs, size_t len)
 245 {
 246   sparc32_collect_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
 247 }
 248
 249 /* Set the program counter for process PTID to PC.  */
 250
 251 #define PSR_SYSCALL     0x00004000
 252
 253 static void
 254 sparc_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
 255 {
 256   struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
 257   ULONGEST psr;
 258
 259   regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
 260   regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);
 261
 262   /* Clear the "in syscall" bit to prevent the kernel from
 263      messing with the PCs we just installed, if we happen to be
 264      within an interrupted system call that the kernel wants to
 265      restart.
 266
 267      Note that after we return from the dummy call, the PSR et al.
 268      registers will be automatically restored, and the kernel
 269      continues to restart the system call at this point.  */
 270   regcache_cooked_read_unsigned (regcache, SPARC32_PSR_REGNUM, &psr);
 271   psr &= ~PSR_SYSCALL;
 272   regcache_cooked_write_unsigned (regcache, SPARC32_PSR_REGNUM, psr);
 273 }
 274
 275 static LONGEST
 276 sparc32_linux_get_syscall_number (struct gdbarch *gdbarch,
 277                                   ptid_t ptid)
 278 {
 279   struct regcache *regcache = get_thread_regcache (ptid);
 280   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 281   /* The content of a register.  */
 282   gdb_byte buf[4];
 283   /* The result.  */
 284   LONGEST ret;
 285
 286   /* Getting the system call number from the register.
 287      When dealing with the sparc architecture, this information
 288      is stored at the %g1 register.  */
 289   regcache_cooked_read (regcache, SPARC_G1_REGNUM, buf);
 290
 291   ret = extract_signed_integer (buf, 4, byte_order);
 292
 293   return ret;
 294 }
 295
 296 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
 297    gdbarch.h.  */
 298
 299 static enum gdb_signal
 300 sparc32_linux_gdb_signal_from_target (struct gdbarch *gdbarch,
 301                                       int signal)
 302 {
 303   switch (signal)
 304     {
 305     case SPARC_LINUX_SIGEMT:
 306       return GDB_SIGNAL_EMT;
 307
 308     case SPARC_LINUX_SIGBUS:
 309       return GDB_SIGNAL_BUS;
 310
 311     case SPARC_LINUX_SIGSYS:
 312       return GDB_SIGNAL_SYS;
 313
 314     case SPARC_LINUX_SIGURG:
 315       return GDB_SIGNAL_URG;
 316
 317     case SPARC_LINUX_SIGSTOP:
 318       return GDB_SIGNAL_STOP;
 319
 320     case SPARC_LINUX_SIGTSTP:
 321       return GDB_SIGNAL_TSTP;
 322
 323     case SPARC_LINUX_SIGCONT:
 324       return GDB_SIGNAL_CONT;
 325
 326     case SPARC_LINUX_SIGCHLD:
 327       return GDB_SIGNAL_CHLD;
 328
 329     /* No way to differentiate between SIGIO and SIGPOLL.
 330        Therefore, we just handle the first one.  */
 331     case SPARC_LINUX_SIGIO:
 332       return GDB_SIGNAL_IO;
 333
 334     /* No way to differentiate between SIGLOST and SIGPWR.
 335        Therefore, we just handle the first one.  */
 336     case SPARC_LINUX_SIGLOST:
 337       return GDB_SIGNAL_LOST;
 338
 339     case SPARC_LINUX_SIGUSR1:
 340       return GDB_SIGNAL_USR1;
 341
 342     case SPARC_LINUX_SIGUSR2:
 343       return GDB_SIGNAL_USR2;
 344     }
 345
 346   return linux_gdb_signal_from_target (gdbarch, signal);
 347 }
 348
 349 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
 350    gdbarch.h.  */
 351
 352 static int
 353 sparc32_linux_gdb_signal_to_target (struct gdbarch *gdbarch,
 354                                     enum gdb_signal signal)
 355 {
 356   switch (signal)
 357     {
 358     case GDB_SIGNAL_EMT:
 359       return SPARC_LINUX_SIGEMT;
 360
 361     case GDB_SIGNAL_BUS:
 362       return SPARC_LINUX_SIGBUS;
 363
 364     case GDB_SIGNAL_SYS:
 365       return SPARC_LINUX_SIGSYS;
 366
 367     case GDB_SIGNAL_URG:
 368       return SPARC_LINUX_SIGURG;
 369
 370     case GDB_SIGNAL_STOP:
 371       return SPARC_LINUX_SIGSTOP;
 372
 373     case GDB_SIGNAL_TSTP:
 374       return SPARC_LINUX_SIGTSTP;
 375
 376     case GDB_SIGNAL_CONT:
 377       return SPARC_LINUX_SIGCONT;
 378
 379     case GDB_SIGNAL_CHLD:
 380       return SPARC_LINUX_SIGCHLD;
 381
 382     case GDB_SIGNAL_IO:
 383       return SPARC_LINUX_SIGIO;
 384
 385     case GDB_SIGNAL_POLL:
 386       return SPARC_LINUX_SIGPOLL;
 387
 388     case GDB_SIGNAL_LOST:
 389       return SPARC_LINUX_SIGLOST;
 390
 391     case GDB_SIGNAL_PWR:
 392       return SPARC_LINUX_SIGPWR;
 393
 394     case GDB_SIGNAL_USR1:
 395       return SPARC_LINUX_SIGUSR1;
 396
 397     case GDB_SIGNAL_USR2:
 398       return SPARC_LINUX_SIGUSR2;
 399     }
 400
 401   return linux_gdb_signal_to_target (gdbarch, signal);
 402 }
 403
 404 \f
 405
 406 static const struct regset sparc32_linux_gregset =
 407   {
 408     NULL,
 409     sparc32_linux_supply_core_gregset,
 410     sparc32_linux_collect_core_gregset
 411   };
 412
 413 static const struct regset sparc32_linux_fpregset =
 414   {
 415     NULL,
 416     sparc32_linux_supply_core_fpregset,
 417     sparc32_linux_collect_core_fpregset
 418   };
 419
 420 static void
 421 sparc32_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 422 {
 423   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 424
 425   linux_init_abi (info, gdbarch);
 426
 427   tdep->gregset = &sparc32_linux_gregset;
 428   tdep->sizeof_gregset = 152;
 429
 430   tdep->fpregset = &sparc32_linux_fpregset;
 431   tdep->sizeof_fpregset = 396;
 432
 433   tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_sigframe);
 434   tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_rt_sigframe);
 435
 436   /* GNU/Linux has SVR4-style shared libraries...  */
 437   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 438   set_solib_svr4_fetch_link_map_offsets
 439     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 440
 441   /* ...which means that we need some special handling when doing
 442      prologue analysis.  */
 443   tdep->plt_entry_size = 12;
 444
 445   /* Enable TLS support.  */
 446   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 447                                              svr4_fetch_objfile_link_map);
 448
 449   /* Make sure we can single-step over signal return system calls.  */
 450   tdep->step_trap = sparc32_linux_step_trap;
 451
 452   /* Hook in the DWARF CFI frame unwinder.  */
 453   dwarf2_append_unwinders (gdbarch);
 454
 455   set_gdbarch_write_pc (gdbarch, sparc_linux_write_pc);
 456
 457   /* Functions for 'catch syscall'.  */
 458   set_xml_syscall_file_name (XML_SYSCALL_FILENAME_SPARC32);
 459   set_gdbarch_get_syscall_number (gdbarch,
 460                                   sparc32_linux_get_syscall_number);
 461
 462   set_gdbarch_gdb_signal_from_target (gdbarch,
 463                                       sparc32_linux_gdb_signal_from_target);
 464   set_gdbarch_gdb_signal_to_target (gdbarch,
 465                                     sparc32_linux_gdb_signal_to_target);
 466 }
 467
 468 /* Provide a prototype to silence -Wmissing-prototypes.  */
 469 extern void _initialize_sparc_linux_tdep (void);
 470
 471 void
 472 _initialize_sparc_linux_tdep (void)
 473 {
 474   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_LINUX,
 475                           sparc32_linux_init_abi);
 476 }