gdb/ia64-linux-tdep.c

   1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
   2
   3    Copyright (C) 2000-2024 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 "extract-store-integer.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_one[16] =
 178     { 0, 0, 0, 0, 0, 0, 0, 0x80, 0xff, 0xff, 0, 0, 0, 0, 0, 0 };
 179
 180   regcache_supply_regset (regset, regcache, regnum, regs, len);
 181
 182   /* Kernel generated cores have fr1==0 instead of 1.0.  Older GDBs
 183      did the same.  So ignore whatever might be recorded in fpregset_t
 184      for fr0/fr1 and always supply their expected values.  */
 185   if (regnum == -1 || regnum == IA64_FR0_REGNUM)
 186     regcache->raw_supply_zeroed (IA64_FR0_REGNUM);
 187   if (regnum == -1 || regnum == IA64_FR1_REGNUM)
 188     regcache->raw_supply (IA64_FR1_REGNUM, f_one);
 189 }
 190
 191 static const struct regset ia64_linux_gregset =
 192   {
 193     ia64_linux_gregmap,
 194     regcache_supply_regset, regcache_collect_regset
 195   };
 196
 197 static const struct regset ia64_linux_fpregset =
 198   {
 199     ia64_linux_fpregmap,
 200     ia64_linux_supply_fpregset, regcache_collect_regset
 201   };
 202
 203 static void
 204 ia64_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 205                                          iterate_over_regset_sections_cb *cb,
 206                                          void *cb_data,
 207                                          const struct regcache *regcache)
 208 {
 209   cb (".reg", IA64_LINUX_GREGS_SIZE, IA64_LINUX_GREGS_SIZE, &ia64_linux_gregset,
 210       NULL, cb_data);
 211   cb (".reg2", IA64_LINUX_FPREGS_SIZE, IA64_LINUX_FPREGS_SIZE,
 212       &ia64_linux_fpregset, NULL, cb_data);
 213 }
 214
 215 static void
 216 ia64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 217 {
 218   ia64_gdbarch_tdep *tdep = gdbarch_tdep<ia64_gdbarch_tdep> (gdbarch);
 219   static const char *const stap_register_prefixes[] = { "r", NULL };
 220   static const char *const stap_register_indirection_prefixes[] = { "[",
 221                                                                     NULL };
 222   static const char *const stap_register_indirection_suffixes[] = { "]",
 223                                                                     NULL };
 224
 225   linux_init_abi (info, gdbarch, 0);
 226
 227   /* Set the method of obtaining the sigcontext addresses at which
 228      registers are saved.  */
 229   tdep->sigcontext_register_address = ia64_linux_sigcontext_register_address;
 230
 231   /* Set the pc_in_sigtramp method.  */
 232   tdep->pc_in_sigtramp = ia64_linux_pc_in_sigtramp;
 233
 234   set_gdbarch_write_pc (gdbarch, ia64_linux_write_pc);
 235
 236   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 237
 238   set_solib_svr4_fetch_link_map_offsets
 239     (gdbarch, linux_lp64_fetch_link_map_offsets);
 240
 241   /* Enable TLS support.  */
 242   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 243                                              svr4_fetch_objfile_link_map);
 244
 245   /* Core file support. */
 246   set_gdbarch_iterate_over_regset_sections
 247     (gdbarch, ia64_linux_iterate_over_regset_sections);
 248
 249   /* SystemTap related.  */
 250   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
 251   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
 252                                           stap_register_indirection_prefixes);
 253   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
 254                                             stap_register_indirection_suffixes);
 255   set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
 256   set_gdbarch_stap_is_single_operand (gdbarch,
 257                                       ia64_linux_stap_is_single_operand);
 258 }
 259
 260 void _initialize_ia64_linux_tdep ();
 261 void
 262 _initialize_ia64_linux_tdep ()
 263 {
 264   gdbarch_register_osabi (bfd_arch_ia64, 0, GDB_OSABI_LINUX,
 265                           ia64_linux_init_abi);
 266 }