1 /* Dynamic architecture support for GDB, the GNU debugger. 2 3 Copyright (C) 1998-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 21 #ifndef GDBARCH_H 22 #define GDBARCH_H 23 24 #include <vector> 25 #include "frame.h" 26 #include "dis-asm.h" 27 #include "gdbsupport/gdb_obstack.h" 28 #include "infrun.h" 29 #include "osabi.h" 30 #include "displaced-stepping.h" 31 #include "gdbsupport/gdb-checked-static-cast.h" 32 #include "registry.h" 33 34 struct floatformat; 35 struct ui_file; 36 struct value; 37 struct objfile; 38 struct obj_section; 39 struct minimal_symbol; 40 struct regcache; 41 struct reggroup; 42 struct regset; 43 struct disassemble_info; 44 struct target_ops; 45 struct obstack; 46 struct bp_target_info; 47 struct target_desc; 48 struct symbol; 49 struct syscall; 50 struct agent_expr; 51 struct axs_value; 52 struct stap_parse_info; 53 struct expr_builder; 54 struct ravenscar_arch_ops; 55 struct mem_range; 56 struct syscalls_info; 57 struct thread_info; 58 struct ui_out; 59 struct inferior; 60 61 #include "regcache.h" 62 63 /* The base class for every architecture's tdep sub-class. The virtual 64 destructor ensures the class has RTTI information, which allows 65 gdb::checked_static_cast to be used in the gdbarch_tdep function. */ 66 67 struct gdbarch_tdep_base 68 { 69 virtual ~gdbarch_tdep_base() = default; 70 }; 71 72 /* The architecture associated with the inferior through the 73 connection to the target. 74 75 The architecture vector provides some information that is really a 76 property of the inferior, accessed through a particular target: 77 ptrace operations; the layout of certain RSP packets; the solib_ops 78 vector; etc. To differentiate architecture accesses to 79 per-inferior/target properties from 80 per-thread/per-frame/per-objfile properties, accesses to 81 per-inferior/target properties should be made through this 82 gdbarch. */ 83 84 /* This is a convenience wrapper for 'current_inferior ()->gdbarch'. */ 85 extern struct gdbarch *target_gdbarch (void); 86 87 /* Callback type for the 'iterate_over_objfiles_in_search_order' 88 gdbarch method. */ 89 90 using iterate_over_objfiles_in_search_order_cb_ftype 91 = gdb::function_view<bool(objfile *)>; 92 93 /* Callback type for regset section iterators. The callback usually 94 invokes the REGSET's supply or collect method, to which it must 95 pass a buffer - for collects this buffer will need to be created using 96 COLLECT_SIZE, for supply the existing buffer being read from should 97 be at least SUPPLY_SIZE. SECT_NAME is a BFD section name, and HUMAN_NAME 98 is used for diagnostic messages. CB_DATA should have been passed 99 unchanged through the iterator. */ 100 101 typedef void (iterate_over_regset_sections_cb) 102 (const char *sect_name, int supply_size, int collect_size, 103 const struct regset *regset, const char *human_name, void *cb_data); 104 105 /* For a function call, does the function return a value using a 106 normal value return or a structure return - passing a hidden 107 argument pointing to storage. For the latter, there are two 108 cases: language-mandated structure return and target ABI 109 structure return. */ 110 111 enum function_call_return_method 112 { 113 /* Standard value return. */ 114 return_method_normal = 0, 115 116 /* Language ABI structure return. This is handled 117 by passing the return location as the first parameter to 118 the function, even preceding "this". */ 119 return_method_hidden_param, 120 121 /* Target ABI struct return. This is target-specific; for instance, 122 on ia64 the first argument is passed in out0 but the hidden 123 structure return pointer would normally be passed in r8. */ 124 return_method_struct, 125 }; 126 127 enum class memtag_type 128 { 129 /* Logical tag, the tag that is stored in unused bits of a pointer to a 130 virtual address. */ 131 logical = 0, 132 133 /* Allocation tag, the tag that is associated with every granule of memory in 134 the physical address space. Allocation tags are used to validate memory 135 accesses via pointers containing logical tags. */ 136 allocation, 137 }; 138 139 /* Callback types for 'read_core_file_mappings' gdbarch method. */ 140 141 using read_core_file_mappings_pre_loop_ftype = 142 gdb::function_view<void (ULONGEST count)>; 143 144 using read_core_file_mappings_loop_ftype = 145 gdb::function_view<void (int num, 146 ULONGEST start, 147 ULONGEST end, 148 ULONGEST file_ofs, 149 const char *filename, 150 const bfd_build_id *build_id)>; 151 152 /* Possible values for gdbarch_call_dummy_location. */ 153 enum call_dummy_location_type 154 { 155 ON_STACK, 156 AT_ENTRY_POINT, 157 }; 158 159 #include "gdbarch-gen.h" 160 161 /* An internal function that should _only_ be called from gdbarch_tdep. 162 Returns the gdbarch_tdep_base field held within GDBARCH. */ 163 164 extern struct gdbarch_tdep_base *gdbarch_tdep_1 (struct gdbarch *gdbarch); 165 166 /* Return the gdbarch_tdep_base object held within GDBARCH cast to the type 167 TDepType, which should be a sub-class of gdbarch_tdep_base. 168 169 When GDB is compiled in maintainer mode a run-time check is performed 170 that the gdbarch_tdep_base within GDBARCH really is of type TDepType. 171 When GDB is compiled in release mode the run-time check is not 172 performed, and we assume the caller knows what they are doing. */ 173 174 template<typename TDepType> 175 static inline TDepType * 176 gdbarch_tdep (struct gdbarch *gdbarch) 177 { 178 struct gdbarch_tdep_base *tdep = gdbarch_tdep_1 (gdbarch); 179 return gdb::checked_static_cast<TDepType *> (tdep); 180 } 181 182 /* Mechanism for co-ordinating the selection of a specific 183 architecture. 184 185 GDB targets (*-tdep.c) can register an interest in a specific 186 architecture. Other GDB components can register a need to maintain 187 per-architecture data. 188 189 The mechanisms below ensures that there is only a loose connection 190 between the set-architecture command and the various GDB 191 components. Each component can independently register their need 192 to maintain architecture specific data with gdbarch. 193 194 Pragmatics: 195 196 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It 197 didn't scale. 198 199 The more traditional mega-struct containing architecture specific 200 data for all the various GDB components was also considered. Since 201 GDB is built from a variable number of (fairly independent) 202 components it was determined that the global aproach was not 203 applicable. */ 204 205 206 /* Register a new architectural family with GDB. 207 208 Register support for the specified ARCHITECTURE with GDB. When 209 gdbarch determines that the specified architecture has been 210 selected, the corresponding INIT function is called. 211 212 -- 213 214 The INIT function takes two parameters: INFO which contains the 215 information available to gdbarch about the (possibly new) 216 architecture; ARCHES which is a list of the previously created 217 ``struct gdbarch'' for this architecture. 218 219 The INFO parameter is, as far as possible, be pre-initialized with 220 information obtained from INFO.ABFD or the global defaults. 221 222 The ARCHES parameter is a linked list (sorted most recently used) 223 of all the previously created architures for this architecture 224 family. The (possibly NULL) ARCHES->gdbarch can used to access 225 values from the previously selected architecture for this 226 architecture family. 227 228 The INIT function shall return any of: NULL - indicating that it 229 doesn't recognize the selected architecture; an existing ``struct 230 gdbarch'' from the ARCHES list - indicating that the new 231 architecture is just a synonym for an earlier architecture (see 232 gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch'' 233 - that describes the selected architecture (see gdbarch_alloc()). 234 235 The DUMP_TDEP function shall print out all target specific values. 236 Care should be taken to ensure that the function works in both the 237 multi-arch and non- multi-arch cases. */ 238 239 struct gdbarch_list 240 { 241 struct gdbarch *gdbarch; 242 struct gdbarch_list *next; 243 }; 244 245 struct gdbarch_info 246 { 247 gdbarch_info () 248 /* Ensure the union is zero-initialized. Relies on the fact that there's 249 no member larger than TDESC_DATA. */ 250 : tdesc_data () 251 {} 252 253 const struct bfd_arch_info *bfd_arch_info = nullptr; 254 255 enum bfd_endian byte_order = BFD_ENDIAN_UNKNOWN; 256 257 enum bfd_endian byte_order_for_code = BFD_ENDIAN_UNKNOWN; 258 259 bfd *abfd = nullptr; 260 261 /* Architecture-specific target description data. */ 262 struct tdesc_arch_data *tdesc_data; 263 264 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN; 265 266 const struct target_desc *target_desc = nullptr; 267 }; 268 269 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches); 270 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file); 271 272 extern void gdbarch_register (enum bfd_architecture architecture, 273 gdbarch_init_ftype *init, 274 gdbarch_dump_tdep_ftype *dump_tdep = nullptr); 275 276 277 /* Return a vector of the valid architecture names. Since architectures are 278 registered during the _initialize phase this function only returns useful 279 information once initialization has been completed. */ 280 281 extern std::vector<const char *> gdbarch_printable_names (); 282 283 284 /* Helper function. Search the list of ARCHES for a GDBARCH that 285 matches the information provided by INFO. */ 286 287 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info); 288 289 290 /* Helper function. Create a preliminary ``struct gdbarch''. Perform 291 basic initialization using values obtained from the INFO and TDEP 292 parameters. set_gdbarch_*() functions are called to complete the 293 initialization of the object. */ 294 295 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep_base *tdep); 296 297 298 /* Helper function. Free a partially-constructed ``struct gdbarch''. 299 It is assumed that the caller freeds the ``struct 300 gdbarch_tdep''. */ 301 302 extern void gdbarch_free (struct gdbarch *); 303 304 /* Get the obstack owned by ARCH. */ 305 306 extern obstack *gdbarch_obstack (gdbarch *arch); 307 308 /* Helper function. Allocate memory from the ``struct gdbarch'' 309 obstack. The memory is freed when the corresponding architecture 310 is also freed. */ 311 312 #define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) obstack_calloc<TYPE> (gdbarch_obstack ((GDBARCH)), (NR)) 313 314 #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) obstack_zalloc<TYPE> (gdbarch_obstack ((GDBARCH))) 315 316 /* Duplicate STRING, returning an equivalent string that's allocated on the 317 obstack associated with GDBARCH. The string is freed when the corresponding 318 architecture is also freed. */ 319 320 extern char *gdbarch_obstack_strdup (struct gdbarch *arch, const char *string); 321 322 /* Helper function. Force an update of the current architecture. 323 324 The actual architecture selected is determined by INFO, ``(gdb) set 325 architecture'' et.al., the existing architecture and BFD's default 326 architecture. INFO should be initialized to zero and then selected 327 fields should be updated. 328 329 Returns non-zero if the update succeeds. */ 330 331 extern int gdbarch_update_p (struct gdbarch_info info); 332 333 334 /* Helper function. Find an architecture matching info. 335 336 INFO should have relevant fields set, and then finished using 337 gdbarch_info_fill. 338 339 Returns the corresponding architecture, or NULL if no matching 340 architecture was found. */ 341 342 extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info); 343 344 345 /* Helper function. Set the target gdbarch to "gdbarch". */ 346 347 extern void set_target_gdbarch (struct gdbarch *gdbarch); 348 349 350 /* A registry adaptor for gdbarch. This arranges to store the 351 registry in the gdbarch. */ 352 template<> 353 struct registry_accessor<gdbarch> 354 { 355 static registry<gdbarch> *get (gdbarch *arch); 356 }; 357 358 /* Set the dynamic target-system-dependent parameters (architecture, 359 byte-order, ...) using information found in the BFD. */ 360 361 extern void set_gdbarch_from_file (bfd *); 362 363 364 /* Initialize the current architecture to the "first" one we find on 365 our list. */ 366 367 extern void initialize_current_architecture (void); 368 369 /* gdbarch trace variable */ 370 extern unsigned int gdbarch_debug; 371 372 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file); 373 374 /* Return the number of cooked registers (raw + pseudo) for ARCH. */ 375 376 static inline int 377 gdbarch_num_cooked_regs (gdbarch *arch) 378 { 379 return gdbarch_num_regs (arch) + gdbarch_num_pseudo_regs (arch); 380 } 381 382 #endif 383