1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger. 2 3 Copyright (C) 2000-2023 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 } 268