gdb/sparc64-linux-tdep.c

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