gdb/ia64-linux-tdep.c

   1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
   2
   3    Copyright (C) 2000-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 "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 (regcache, IA64_FR0_REGNUM, f_zero);
 188   if (regnum == -1 || regnum == IA64_FR1_REGNUM)
 189     regcache_raw_supply (regcache, 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 const struct regset *
 205 ia64_linux_regset_from_core_section (struct gdbarch *gdbarch,
 206                                      const char *sect_name,
 207                                      size_t sect_size)
 208 {
 209   if (strcmp (sect_name, ".reg") == 0
 210       && sect_size >= IA64_LINUX_GREGS_SIZE)
 211     return &ia64_linux_gregset;
 212
 213   if (strcmp (sect_name, ".reg2") == 0
 214       && sect_size >= IA64_LINUX_FPREGS_SIZE)
 215     return &ia64_linux_fpregset;
 216
 217   return NULL;
 218 }
 219
 220 static void
 221 ia64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 222 {
 223   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 224   static const char *const stap_register_prefixes[] = { "r", NULL };
 225   static const char *const stap_register_indirection_prefixes[] = { "[",
 226                                                                     NULL };
 227   static const char *const stap_register_indirection_suffixes[] = { "]",
 228                                                                     NULL };
 229
 230   linux_init_abi (info, gdbarch);
 231
 232   /* Set the method of obtaining the sigcontext addresses at which
 233      registers are saved.  */
 234   tdep->sigcontext_register_address = ia64_linux_sigcontext_register_address;
 235
 236   /* Set the pc_in_sigtramp method.  */
 237   tdep->pc_in_sigtramp = ia64_linux_pc_in_sigtramp;
 238
 239   set_gdbarch_write_pc (gdbarch, ia64_linux_write_pc);
 240
 241   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 242
 243   set_solib_svr4_fetch_link_map_offsets
 244     (gdbarch, svr4_lp64_fetch_link_map_offsets);
 245
 246   /* Enable TLS support.  */
 247   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 248                                              svr4_fetch_objfile_link_map);
 249
 250   /* Core file support. */
 251   set_gdbarch_regset_from_core_section (gdbarch,
 252                                         ia64_linux_regset_from_core_section);
 253
 254   /* SystemTap related.  */
 255   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
 256   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
 257                                           stap_register_indirection_prefixes);
 258   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
 259                                             stap_register_indirection_suffixes);
 260   set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
 261   set_gdbarch_stap_is_single_operand (gdbarch,
 262                                       ia64_linux_stap_is_single_operand);
 263 }
 264
 265 /* Provide a prototype to silence -Wmissing-prototypes.  */
 266 extern initialize_file_ftype _initialize_ia64_linux_tdep;
 267
 268 void
 269 _initialize_ia64_linux_tdep (void)
 270 {
 271   gdbarch_register_osabi (bfd_arch_ia64, 0, GDB_OSABI_LINUX,
 272                           ia64_linux_init_abi);
 273 }