gdb/sparc64-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux UltraSPARC.
   2
   3    Copyright (C) 2003-2016 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   CORE_ADDR jb_addr;
 245   gdb_byte buf[8];
 246
 247   jb_addr = get_frame_register_unsigned (frame, SPARC_O0_REGNUM);
 248
 249   /* setjmp and longjmp in SPARC64 are implemented in glibc using the
 250      setcontext and getcontext system calls respectively.  These
 251      system calls operate on ucontext_t structures, which happen to
 252      partially have the same structure than jmp_buf.  However the
 253      ucontext returned by getcontext, and thus the jmp_buf structure
 254      returned by setjmp, contains the context of the trap instruction
 255      in the glibc __[sig]setjmp wrapper, not the context of the user
 256      code calling setjmp.
 257
 258      %o7 in the jmp_buf structure is stored at offset 18*8 in the
 259      mc_gregs array, which is itself located at offset 32 into
 260      jmp_buf.  See bits/setjmp.h.  This register contains the address
 261      of the 'call setjmp' instruction in user code.
 262
 263      In order to determine the longjmp target address in the
 264      initiating frame we need to examine the call instruction itself,
 265      in particular whether the annul bit is set.  If it is not set
 266      then we need to jump over the instruction at the delay slot.  */
 267
 268   if (target_read_memory (jb_addr + 32 + (18 * 8), buf, 8))
 269     return 0;
 270
 271   *pc = extract_unsigned_integer (buf, 8, gdbarch_byte_order (gdbarch));
 272
 273   if (!sparc_is_annulled_branch_insn (*pc))
 274       *pc += 4; /* delay slot insn  */
 275   *pc += 4; /* call insn  */
 276
 277   return 1;
 278 }
 279
 280 \f
 281
 282 static const struct regset sparc64_linux_gregset =
 283   {
 284     NULL,
 285     sparc64_linux_supply_core_gregset,
 286     sparc64_linux_collect_core_gregset
 287   };
 288
 289 static const struct regset sparc64_linux_fpregset =
 290   {
 291     NULL,
 292     sparc64_linux_supply_core_fpregset,
 293     sparc64_linux_collect_core_fpregset
 294   };
 295
 296 static void
 297 sparc64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 298 {
 299   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 300
 301   linux_init_abi (info, gdbarch);
 302
 303   tdep->gregset = &sparc64_linux_gregset;
 304   tdep->sizeof_gregset = 288;
 305
 306   tdep->fpregset = &sparc64_linux_fpregset;
 307   tdep->sizeof_fpregset = 280;
 308
 309   tramp_frame_prepend_unwinder (gdbarch, &sparc64_linux_rt_sigframe);
 310
 311   /* Hook in the DWARF CFI frame unwinder.  */
 312   dwarf2_append_unwinders (gdbarch);
 313
 314   sparc64_init_abi (info, gdbarch);
 315
 316   /* GNU/Linux has SVR4-style shared libraries...  */
 317   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 318   set_solib_svr4_fetch_link_map_offsets
 319     (gdbarch, svr4_lp64_fetch_link_map_offsets);
 320
 321   /* ...which means that we need some special handling when doing
 322      prologue analysis.  */
 323   tdep->plt_entry_size = 16;
 324
 325   /* Enable TLS support.  */
 326   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 327                                              svr4_fetch_objfile_link_map);
 328
 329   /* Make sure we can single-step over signal return system calls.  */
 330   tdep->step_trap = sparc64_linux_step_trap;
 331
 332   /* Make sure we can single-step over longjmp calls.  */
 333   set_gdbarch_get_longjmp_target (gdbarch, sparc64_linux_get_longjmp_target);
 334
 335   set_gdbarch_write_pc (gdbarch, sparc64_linux_write_pc);
 336
 337   /* Functions for 'catch syscall'.  */
 338   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_SPARC64);
 339   set_gdbarch_get_syscall_number (gdbarch,
 340                                   sparc64_linux_get_syscall_number);
 341 }
 342 \f
 343
 344 /* Provide a prototype to silence -Wmissing-prototypes.  */
 345 extern void _initialize_sparc64_linux_tdep (void);
 346
 347 void
 348 _initialize_sparc64_linux_tdep (void)
 349 {
 350   gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
 351                           GDB_OSABI_LINUX, sparc64_linux_init_abi);
 352 }