gdb/ia64-linux-tdep.c

   1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
   2
   3    Copyright (C) 2000-2022 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 "ia64-tdep.h"
  22 #include "arch-utils.h"
  23 #include "gdbcore.h"
  24 #include "regcache.h"
  25 #include "osabi.h"
  26 #include "solib-svr4.h"
  27 #include "symtab.h"
  28 #include "linux-tdep.h"
  29 #include "regset.h"
  30
  31 #include <ctype.h>
  32
  33 /* The sigtramp code is in a non-readable (executable-only) region
  34    of memory called the ``gate page''.  The addresses in question
  35    were determined by examining the system headers.  They are
  36    overly generous to allow for different pages sizes.  */
  37
  38 #define GATE_AREA_START 0xa000000000000100LL
  39 #define GATE_AREA_END   0xa000000000020000LL
  40
  41 /* Offset to sigcontext structure from frame of handler.  */
  42 #define IA64_LINUX_SIGCONTEXT_OFFSET 192
  43
  44 static int
  45 ia64_linux_pc_in_sigtramp (CORE_ADDR pc)
  46 {
  47   return (pc >= (CORE_ADDR) GATE_AREA_START && pc < (CORE_ADDR) GATE_AREA_END);
  48 }
  49
  50 /* IA-64 GNU/Linux specific function which, given a frame address and
  51    a register number, returns the address at which that register may be
  52    found.  0 is returned for registers which aren't stored in the
  53    sigcontext structure.  */
  54
  55 static CORE_ADDR
  56 ia64_linux_sigcontext_register_address (struct gdbarch *gdbarch,
  57                                         CORE_ADDR sp, int regno)
  58 {
  59   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  60   gdb_byte buf[8];
  61   CORE_ADDR sigcontext_addr = 0;
  62
  63   /* The address of the sigcontext area is found at offset 16 in the
  64      sigframe.  */
  65   read_memory (sp + 16, buf, 8);
  66   sigcontext_addr = extract_unsigned_integer (buf, 8, byte_order);
  67
  68   if (IA64_GR0_REGNUM <= regno && regno <= IA64_GR31_REGNUM)
  69     return sigcontext_addr + 200 + 8 * (regno - IA64_GR0_REGNUM);
  70   else if (IA64_BR0_REGNUM <= regno && regno <= IA64_BR7_REGNUM)
  71     return sigcontext_addr + 136 + 8 * (regno - IA64_BR0_REGNUM);
  72   else if (IA64_FR0_REGNUM <= regno && regno <= IA64_FR127_REGNUM)
  73     return sigcontext_addr + 464 + 16 * (regno - IA64_FR0_REGNUM);
  74   else
  75     switch (regno)
  76       {
  77       case IA64_IP_REGNUM :
  78         return sigcontext_addr + 40;
  79       case IA64_CFM_REGNUM :
  80         return sigcontext_addr + 48;
  81       case IA64_PSR_REGNUM :
  82         return sigcontext_addr + 56;            /* user mask only */
  83       /* sc_ar_rsc is provided, from which we could compute bspstore, but
  84          I don't think it's worth it.  Anyway, if we want it, it's at offset
  85          64.  */
  86       case IA64_BSP_REGNUM :
  87         return sigcontext_addr + 72;
  88       case IA64_RNAT_REGNUM :
  89         return sigcontext_addr + 80;
  90       case IA64_CCV_REGNUM :
  91         return sigcontext_addr + 88;
  92       case IA64_UNAT_REGNUM :
  93         return sigcontext_addr + 96;
  94       case IA64_FPSR_REGNUM :
  95         return sigcontext_addr + 104;
  96       case IA64_PFS_REGNUM :
  97         return sigcontext_addr + 112;
  98       case IA64_LC_REGNUM :
  99         return sigcontext_addr + 120;
 100       case IA64_PR_REGNUM :
 101         return sigcontext_addr + 128;
 102       default :
 103         return 0;
 104       }
 105 }
 106
 107 static void
 108 ia64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
 109 {
 110   ia64_write_pc (regcache, pc);
 111
 112   /* We must be careful with modifying the instruction-pointer: if we
 113      just interrupt a system call, the kernel would ordinarily try to
 114      restart it when we resume the inferior, which typically results
 115      in SIGSEGV or SIGILL.  We prevent this by clearing r10, which
 116      will tell the kernel that r8 does NOT contain a valid error code
 117      and hence it will skip system-call restart.
 118
 119      The clearing of r10 is safe as long as ia64_write_pc() is only
 120      called as part of setting up an inferior call.  */
 121   regcache_cooked_write_unsigned (regcache, IA64_GR10_REGNUM, 0);
 122 }
 123
 124 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
 125    gdbarch.h.  */
 126
 127 static int
 128 ia64_linux_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
 129 {
 130   return ((isdigit (*s) && s[1] == '[' && s[2] == 'r') /* Displacement.  */
 131           || *s == 'r' /* Register value.  */
 132           || isdigit (*s));  /* Literal number.  */
 133 }
 134
 135 /* Core file support. */
 136
 137 static const struct regcache_map_entry ia64_linux_gregmap[] =
 138   {
 139     { 32, IA64_GR0_REGNUM, 8 }, /* r0 ... r31 */
 140     { 1, REGCACHE_MAP_SKIP, 8 }, /* FIXME: NAT collection bits? */
 141     { 1, IA64_PR_REGNUM, 8 },
 142     { 8, IA64_BR0_REGNUM, 8 },  /* b0 ... b7 */
 143     { 1, IA64_IP_REGNUM, 8 },
 144     { 1, IA64_CFM_REGNUM, 8 },
 145     { 1, IA64_PSR_REGNUM, 8 },
 146     { 1, IA64_RSC_REGNUM, 8 },
 147     { 1, IA64_BSP_REGNUM, 8 },
 148     { 1, IA64_BSPSTORE_REGNUM, 8 },
 149     { 1, IA64_RNAT_REGNUM, 8 },
 150     { 1, IA64_CCV_REGNUM, 8 },
 151     { 1, IA64_UNAT_REGNUM, 8 },
 152     { 1, IA64_FPSR_REGNUM, 8 },
 153     { 1, IA64_PFS_REGNUM, 8 },
 154     { 1, IA64_LC_REGNUM, 8 },
 155     { 1, IA64_EC_REGNUM, 8 },
 156     { 0 }
 157   };
 158
 159 /* Size of 'gregset_t', as defined by the Linux kernel.  Note that
 160    this is more than actually mapped in the regmap above.  */
 161
 162 #define IA64_LINUX_GREGS_SIZE (128 * 8)
 163
 164 static const struct regcache_map_entry ia64_linux_fpregmap[] =
 165   {
 166     { 128, IA64_FR0_REGNUM, 16 }, /* f0 ... f127 */
 167     { 0 }
 168   };
 169
 170 #define IA64_LINUX_FPREGS_SIZE (128 * 16)
 171
 172 static void
 173 ia64_linux_supply_fpregset (const struct regset *regset,
 174                             struct regcache *regcache,
 175                             int regnum, const void *regs, size_t len)
 176 {
 177   const gdb_byte f_zero[16] = { 0 };
 178   const gdb_byte f_one[16] =
 179     { 0, 0, 0, 0, 0, 0, 0, 0x80, 0xff, 0xff, 0, 0, 0, 0, 0, 0 };
 180
 181   regcache_supply_regset (regset, regcache, regnum, regs, len);
 182
 183   /* Kernel generated cores have fr1==0 instead of 1.0.  Older GDBs
 184      did the same.  So ignore whatever might be recorded in fpregset_t
 185      for fr0/fr1 and always supply their expected values.  */
 186   if (regnum == -1 || regnum == IA64_FR0_REGNUM)
 187     regcache->raw_supply (IA64_FR0_REGNUM, f_zero);
 188   if (regnum == -1 || regnum == IA64_FR1_REGNUM)
 189     regcache->raw_supply (IA64_FR1_REGNUM, f_one);
 190 }
 191
 192 static const struct regset ia64_linux_gregset =
 193   {
 194     ia64_linux_gregmap,
 195     regcache_supply_regset, regcache_collect_regset
 196   };
 197
 198 static const struct regset ia64_linux_fpregset =
 199   {
 200     ia64_linux_fpregmap,
 201     ia64_linux_supply_fpregset, regcache_collect_regset
 202   };
 203
 204 static void
 205 ia64_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 206                                          iterate_over_regset_sections_cb *cb,
 207                                          void *cb_data,
 208                                          const struct regcache *regcache)
 209 {
 210   cb (".reg", IA64_LINUX_GREGS_SIZE, IA64_LINUX_GREGS_SIZE, &ia64_linux_gregset,
 211       NULL, cb_data);
 212   cb (".reg2", IA64_LINUX_FPREGS_SIZE, IA64_LINUX_FPREGS_SIZE,
 213       &ia64_linux_fpregset, NULL, cb_data);
 214 }
 215
 216 static void
 217 ia64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 218 {
 219   ia64_gdbarch_tdep *tdep = gdbarch_tdep<ia64_gdbarch_tdep> (gdbarch);
 220   static const char *const stap_register_prefixes[] = { "r", NULL };
 221   static const char *const stap_register_indirection_prefixes[] = { "[",
 222                                                                     NULL };
 223   static const char *const stap_register_indirection_suffixes[] = { "]",
 224                                                                     NULL };
 225
 226   linux_init_abi (info, gdbarch, 0);
 227
 228   /* Set the method of obtaining the sigcontext addresses at which
 229      registers are saved.  */
 230   tdep->sigcontext_register_address = ia64_linux_sigcontext_register_address;
 231
 232   /* Set the pc_in_sigtramp method.  */
 233   tdep->pc_in_sigtramp = ia64_linux_pc_in_sigtramp;
 234
 235   set_gdbarch_write_pc (gdbarch, ia64_linux_write_pc);
 236
 237   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 238
 239   set_solib_svr4_fetch_link_map_offsets
 240     (gdbarch, linux_lp64_fetch_link_map_offsets);
 241
 242   /* Enable TLS support.  */
 243   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 244                                              svr4_fetch_objfile_link_map);
 245
 246   /* Core file support. */
 247   set_gdbarch_iterate_over_regset_sections
 248     (gdbarch, ia64_linux_iterate_over_regset_sections);
 249
 250   /* SystemTap related.  */
 251   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
 252   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
 253                                           stap_register_indirection_prefixes);
 254   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
 255                                             stap_register_indirection_suffixes);
 256   set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
 257   set_gdbarch_stap_is_single_operand (gdbarch,
 258                                       ia64_linux_stap_is_single_operand);
 259 }
 260
 261 void _initialize_ia64_linux_tdep ();
 262 void
 263 _initialize_ia64_linux_tdep ()
 264 {
 265   gdbarch_register_osabi (bfd_arch_ia64, 0, GDB_OSABI_LINUX,
 266                           ia64_linux_init_abi);
 267 }