gdb/sparc64-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux UltraSPARC.
   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 "frame.h"
  22 #include "frame-unwind.h"
  23 #include "dwarf2-frame.h"
  24 #include "regset.h"
  25 #include "regcache.h"
  26 #include "gdbarch.h"
  27 #include "gdbcore.h"
  28 #include "osabi.h"
  29 #include "solib-svr4.h"
  30 #include "symtab.h"
  31 #include "trad-frame.h"
  32 #include "tramp-frame.h"
  33 #include "xml-syscall.h"
  34 #include "linux-tdep.h"
  35
  36 /* The syscall's XML filename for sparc 64-bit.  */
  37 #define XML_SYSCALL_FILENAME_SPARC64 "syscalls/sparc64-linux.xml"
  38
  39 #include "sparc64-tdep.h"
  40
  41 /* Signal trampoline support.  */
  42
  43 static void sparc64_linux_sigframe_init (const struct tramp_frame *self,
  44                                          struct frame_info *this_frame,
  45                                          struct trad_frame_cache *this_cache,
  46                                          CORE_ADDR func);
  47
  48 /* See sparc-linux-tdep.c for details.  Note that 64-bit binaries only
  49    use RT signals.  */
  50
  51 static const struct tramp_frame sparc64_linux_rt_sigframe =
  52 {
  53   SIGTRAMP_FRAME,
  54   4,
  55   {
  56     { 0x82102065, -1 },         /* mov __NR_rt_sigreturn, %g1 */
  57     { 0x91d0206d, -1 },         /* ta  0x6d */
  58     { TRAMP_SENTINEL_INSN, -1 }
  59   },
  60   sparc64_linux_sigframe_init
  61 };
  62
  63 static void
  64 sparc64_linux_sigframe_init (const struct tramp_frame *self,
  65                              struct frame_info *this_frame,
  66                              struct trad_frame_cache *this_cache,
  67                              CORE_ADDR func)
  68 {
  69   CORE_ADDR base, addr, sp_addr;
  70   int regnum;
  71
  72   base = get_frame_register_unsigned (this_frame, SPARC_O1_REGNUM);
  73   base += 128;
  74
  75   /* Offsets from <bits/sigcontext.h>.  */
  76
  77   /* Since %g0 is always zero, keep the identity encoding.  */
  78   addr = base + 8;
  79   sp_addr = base + ((SPARC_SP_REGNUM - SPARC_G0_REGNUM) * 8);
  80   for (regnum = SPARC_G1_REGNUM; regnum <= SPARC_O7_REGNUM; regnum++)
  81     {
  82       trad_frame_set_reg_addr (this_cache, regnum, addr);
  83       addr += 8;
  84     }
  85
  86   trad_frame_set_reg_addr (this_cache, SPARC64_STATE_REGNUM, addr + 0);
  87   trad_frame_set_reg_addr (this_cache, SPARC64_PC_REGNUM, addr + 8);
  88   trad_frame_set_reg_addr (this_cache, SPARC64_NPC_REGNUM, addr + 16);
  89   trad_frame_set_reg_addr (this_cache, SPARC64_Y_REGNUM, addr + 24);
  90   trad_frame_set_reg_addr (this_cache, SPARC64_FPRS_REGNUM, addr + 28);
  91
  92   base = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
  93   if (base & 1)
  94     base += BIAS;
  95
  96   addr = get_frame_memory_unsigned (this_frame, sp_addr, 8);
  97   if (addr & 1)
  98     addr += BIAS;
  99
 100   for (regnum = SPARC_L0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
 101     {
 102       trad_frame_set_reg_addr (this_cache, regnum, addr);
 103       addr += 8;
 104     }
 105   trad_frame_set_id (this_cache, frame_id_build (base, func));
 106 }
 107 \f
 108 /* Return the address of a system call's alternative return
 109    address.  */
 110
 111 static CORE_ADDR
 112 sparc64_linux_step_trap (struct frame_info *frame, unsigned long insn)
 113 {
 114   /* __NR_rt_sigreturn is 101  */
 115   if ((insn == 0x91d0206d)
 116       && (get_frame_register_unsigned (frame, SPARC_G1_REGNUM) == 101))
 117     {
 118       struct gdbarch *gdbarch = get_frame_arch (frame);
 119       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 120
 121       ULONGEST sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
 122       if (sp & 1)
 123         sp += BIAS;
 124
 125       /* The kernel puts the sigreturn registers on the stack,
 126          and this is where the signal unwinding state is take from
 127          when returning from a signal.
 128
 129          A siginfo_t sits 192 bytes from the base of the stack.  This
 130          siginfo_t is 128 bytes, and is followed by the sigreturn
 131          register save area.  The saved PC sits at a 136 byte offset
 132          into there.  */
 133
 134       return read_memory_unsigned_integer (sp + 192 + 128 + 136,
 135                                            8, byte_order);
 136     }
 137
 138   return 0;
 139 }
 140 \f
 141
 142 const struct sparc_gregmap sparc64_linux_core_gregmap =
 143 {
 144   32 * 8,                       /* %tstate */
 145   33 * 8,                       /* %tpc */
 146   34 * 8,                       /* %tnpc */
 147   35 * 8,                       /* %y */
 148   -1,                           /* %wim */
 149   -1,                           /* %tbr */
 150   1 * 8,                        /* %g1 */
 151   16 * 8,                       /* %l0 */
 152   8,                            /* y size */
 153 };
 154 \f
 155
 156 static void
 157 sparc64_linux_supply_core_gregset (const struct regset *regset,
 158                                    struct regcache *regcache,
 159                                    int regnum, const void *gregs, size_t len)
 160 {
 161   sparc64_supply_gregset (&sparc64_linux_core_gregmap,
 162                           regcache, regnum, gregs);
 163 }
 164
 165 static void
 166 sparc64_linux_collect_core_gregset (const struct regset *regset,
 167                                     const struct regcache *regcache,
 168                                     int regnum, void *gregs, size_t len)
 169 {
 170   sparc64_collect_gregset (&sparc64_linux_core_gregmap,
 171                            regcache, regnum, gregs);
 172 }
 173
 174 static void
 175 sparc64_linux_supply_core_fpregset (const struct regset *regset,
 176                                     struct regcache *regcache,
 177                                     int regnum, const void *fpregs, size_t len)
 178 {
 179   sparc64_supply_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs);
 180 }
 181
 182 static void
 183 sparc64_linux_collect_core_fpregset (const struct regset *regset,
 184                                      const struct regcache *regcache,
 185                                      int regnum, void *fpregs, size_t len)
 186 {
 187   sparc64_collect_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs);
 188 }
 189
 190 /* Set the program counter for process PTID to PC.  */
 191
 192 #define TSTATE_SYSCALL  0x0000000000000020ULL
 193
 194 static void
 195 sparc64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
 196 {
 197   struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
 198   ULONGEST state;
 199
 200   regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
 201   regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);
 202
 203   /* Clear the "in syscall" bit to prevent the kernel from
 204      messing with the PCs we just installed, if we happen to be
 205      within an interrupted system call that the kernel wants to
 206      restart.
 207
 208      Note that after we return from the dummy call, the TSTATE et al.
 209      registers will be automatically restored, and the kernel
 210      continues to restart the system call at this point.  */
 211   regcache_cooked_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
 212   state &= ~TSTATE_SYSCALL;
 213   regcache_cooked_write_unsigned (regcache, SPARC64_STATE_REGNUM, state);
 214 }
 215
 216 static LONGEST
 217 sparc64_linux_get_syscall_number (struct gdbarch *gdbarch,
 218                                   ptid_t ptid)
 219 {
 220   struct regcache *regcache = get_thread_regcache (ptid);
 221   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 222   /* The content of a register.  */
 223   gdb_byte buf[8];
 224   /* The result.  */
 225   LONGEST ret;
 226
 227   /* Getting the system call number from the register.
 228      When dealing with the sparc architecture, this information
 229      is stored at the %g1 register.  */
 230   regcache_cooked_read (regcache, SPARC_G1_REGNUM, buf);
 231
 232   ret = extract_signed_integer (buf, 8, byte_order);
 233
 234   return ret;
 235 }
 236
 237 \f
 238 /* Implement the "get_longjmp_target" gdbarch method.  */
 239
 240 static int
 241 sparc64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
 242 {
 243   struct gdbarch *gdbarch = get_frame_arch (frame);
 244   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 245   CORE_ADDR jb_addr;
 246   gdb_byte buf[8];
 247
 248   jb_addr = get_frame_register_unsigned (frame, SPARC_O0_REGNUM);
 249
 250   /* setjmp and longjmp in SPARC64 are implemented in glibc using the
 251      setcontext and getcontext system calls respectively.  These
 252      system calls operate on ucontext_t structures, which happen to
 253      partially have the same structure than jmp_buf.  However the
 254      ucontext returned by getcontext, and thus the jmp_buf structure
 255      returned by setjmp, contains the context of the trap instruction
 256      in the glibc __[sig]setjmp wrapper, not the context of the user
 257      code calling setjmp.
 258
 259      %o7 in the jmp_buf structure is stored at offset 18*8 in the
 260      mc_gregs array, which is itself located at offset 32 into
 261      jmp_buf.  See bits/setjmp.h.  This register contains the address
 262      of the 'call setjmp' instruction in user code.
 263
 264      In order to determine the longjmp target address in the
 265      initiating frame we need to examine the call instruction itself,
 266      in particular whether the annul bit is set.  If it is not set
 267      then we need to jump over the instruction at the delay slot.  */
 268
 269   if (target_read_memory (jb_addr + 32 + (18 * 8), buf, 8))
 270     return 0;
 271
 272   *pc = extract_unsigned_integer (buf, 8, gdbarch_byte_order (gdbarch));
 273
 274   if (!sparc_is_annulled_branch_insn (*pc))
 275       *pc += 4; /* delay slot insn  */
 276   *pc += 4; /* call insn  */
 277
 278   return 1;
 279 }
 280
 281 \f
 282
 283 static const struct regset sparc64_linux_gregset =
 284   {
 285     NULL,
 286     sparc64_linux_supply_core_gregset,
 287     sparc64_linux_collect_core_gregset
 288   };
 289
 290 static const struct regset sparc64_linux_fpregset =
 291   {
 292     NULL,
 293     sparc64_linux_supply_core_fpregset,
 294     sparc64_linux_collect_core_fpregset
 295   };
 296
 297 static void
 298 sparc64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 299 {
 300   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 301
 302   linux_init_abi (info, gdbarch);
 303
 304   tdep->gregset = &sparc64_linux_gregset;
 305   tdep->sizeof_gregset = 288;
 306
 307   tdep->fpregset = &sparc64_linux_fpregset;
 308   tdep->sizeof_fpregset = 280;
 309
 310   tramp_frame_prepend_unwinder (gdbarch, &sparc64_linux_rt_sigframe);
 311
 312   /* Hook in the DWARF CFI frame unwinder.  */
 313   dwarf2_append_unwinders (gdbarch);
 314
 315   sparc64_init_abi (info, gdbarch);
 316
 317   /* GNU/Linux has SVR4-style shared libraries...  */
 318   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 319   set_solib_svr4_fetch_link_map_offsets
 320     (gdbarch, svr4_lp64_fetch_link_map_offsets);
 321
 322   /* ...which means that we need some special handling when doing
 323      prologue analysis.  */
 324   tdep->plt_entry_size = 16;
 325
 326   /* Enable TLS support.  */
 327   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 328                                              svr4_fetch_objfile_link_map);
 329
 330   /* Make sure we can single-step over signal return system calls.  */
 331   tdep->step_trap = sparc64_linux_step_trap;
 332
 333   /* Make sure we can single-step over longjmp calls.  */
 334   set_gdbarch_get_longjmp_target (gdbarch, sparc64_linux_get_longjmp_target);
 335
 336   set_gdbarch_write_pc (gdbarch, sparc64_linux_write_pc);
 337
 338   /* Functions for 'catch syscall'.  */
 339   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_SPARC64);
 340   set_gdbarch_get_syscall_number (gdbarch,
 341                                   sparc64_linux_get_syscall_number);
 342 }
 343 \f
 344
 345 /* Provide a prototype to silence -Wmissing-prototypes.  */
 346 extern void _initialize_sparc64_linux_tdep (void);
 347
 348 void
 349 _initialize_sparc64_linux_tdep (void)
 350 {
 351   gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
 352                           GDB_OSABI_LINUX, sparc64_linux_init_abi);
 353 }