gdb/gdbarch.h

   1 /* Dynamic architecture support for GDB, the GNU debugger.
   2
   3    Copyright (C) 1998-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
  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 #include "gdbarch-gen.h"
 153
 154 /* An internal function that should _only_ be called from gdbarch_tdep.
 155    Returns the gdbarch_tdep_base field held within GDBARCH.  */
 156
 157 extern struct gdbarch_tdep_base *gdbarch_tdep_1 (struct gdbarch *gdbarch);
 158
 159 /* Return the gdbarch_tdep_base object held within GDBARCH cast to the type
 160    TDepType, which should be a sub-class of gdbarch_tdep_base.
 161
 162    When GDB is compiled in maintainer mode a run-time check is performed
 163    that the gdbarch_tdep_base within GDBARCH really is of type TDepType.
 164    When GDB is compiled in release mode the run-time check is not
 165    performed, and we assume the caller knows what they are doing.  */
 166
 167 template<typename TDepType>
 168 static inline TDepType *
 169 gdbarch_tdep (struct gdbarch *gdbarch)
 170 {
 171   struct gdbarch_tdep_base *tdep = gdbarch_tdep_1 (gdbarch);
 172   return gdb::checked_static_cast<TDepType *> (tdep);
 173 }
 174
 175 /* Mechanism for co-ordinating the selection of a specific
 176    architecture.
 177
 178    GDB targets (*-tdep.c) can register an interest in a specific
 179    architecture.  Other GDB components can register a need to maintain
 180    per-architecture data.
 181
 182    The mechanisms below ensures that there is only a loose connection
 183    between the set-architecture command and the various GDB
 184    components.  Each component can independently register their need
 185    to maintain architecture specific data with gdbarch.
 186
 187    Pragmatics:
 188
 189    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
 190    didn't scale.
 191
 192    The more traditional mega-struct containing architecture specific
 193    data for all the various GDB components was also considered.  Since
 194    GDB is built from a variable number of (fairly independent)
 195    components it was determined that the global aproach was not
 196    applicable.  */
 197
 198
 199 /* Register a new architectural family with GDB.
 200
 201    Register support for the specified ARCHITECTURE with GDB.  When
 202    gdbarch determines that the specified architecture has been
 203    selected, the corresponding INIT function is called.
 204
 205    --
 206
 207    The INIT function takes two parameters: INFO which contains the
 208    information available to gdbarch about the (possibly new)
 209    architecture; ARCHES which is a list of the previously created
 210    ``struct gdbarch'' for this architecture.
 211
 212    The INFO parameter is, as far as possible, be pre-initialized with
 213    information obtained from INFO.ABFD or the global defaults.
 214
 215    The ARCHES parameter is a linked list (sorted most recently used)
 216    of all the previously created architures for this architecture
 217    family.  The (possibly NULL) ARCHES->gdbarch can used to access
 218    values from the previously selected architecture for this
 219    architecture family.
 220
 221    The INIT function shall return any of: NULL - indicating that it
 222    doesn't recognize the selected architecture; an existing ``struct
 223    gdbarch'' from the ARCHES list - indicating that the new
 224    architecture is just a synonym for an earlier architecture (see
 225    gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
 226    - that describes the selected architecture (see gdbarch_alloc()).
 227
 228    The DUMP_TDEP function shall print out all target specific values.
 229    Care should be taken to ensure that the function works in both the
 230    multi-arch and non- multi-arch cases.  */
 231
 232 struct gdbarch_list
 233 {
 234   struct gdbarch *gdbarch;
 235   struct gdbarch_list *next;
 236 };
 237
 238 struct gdbarch_info
 239 {
 240   gdbarch_info ()
 241     /* Ensure the union is zero-initialized.  Relies on the fact that there's
 242        no member larger than TDESC_DATA.  */
 243     : tdesc_data ()
 244   {}
 245
 246   const struct bfd_arch_info *bfd_arch_info = nullptr;
 247
 248   enum bfd_endian byte_order = BFD_ENDIAN_UNKNOWN;
 249
 250   enum bfd_endian byte_order_for_code = BFD_ENDIAN_UNKNOWN;
 251
 252   bfd *abfd = nullptr;
 253
 254   union
 255     {
 256       /* Architecture-specific target description data.  Numerous targets
 257          need only this, so give them an easy way to hold it.  */
 258       struct tdesc_arch_data *tdesc_data;
 259
 260       /* SPU file system ID.  This is a single integer, so using the
 261          generic form would only complicate code.  Other targets may
 262          reuse this member if suitable.  */
 263       int *id;
 264     };
 265
 266   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
 267
 268   const struct target_desc *target_desc = nullptr;
 269 };
 270
 271 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
 272 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
 273
 274 /* DEPRECATED - use gdbarch_register() */
 275 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
 276
 277 extern void gdbarch_register (enum bfd_architecture architecture,
 278                               gdbarch_init_ftype *,
 279                               gdbarch_dump_tdep_ftype *);
 280
 281
 282 /* Return a vector of the valid architecture names.  Since architectures are
 283    registered during the _initialize phase this function only returns useful
 284    information once initialization has been completed.  */
 285
 286 extern std::vector<const char *> gdbarch_printable_names ();
 287
 288
 289 /* Helper function.  Search the list of ARCHES for a GDBARCH that
 290    matches the information provided by INFO.  */
 291
 292 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
 293
 294
 295 /* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
 296    basic initialization using values obtained from the INFO and TDEP
 297    parameters.  set_gdbarch_*() functions are called to complete the
 298    initialization of the object.  */
 299
 300 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep_base *tdep);
 301
 302
 303 /* Helper function.  Free a partially-constructed ``struct gdbarch''.
 304    It is assumed that the caller freeds the ``struct
 305    gdbarch_tdep''.  */
 306
 307 extern void gdbarch_free (struct gdbarch *);
 308
 309 /* Get the obstack owned by ARCH.  */
 310
 311 extern obstack *gdbarch_obstack (gdbarch *arch);
 312
 313 /* Helper function.  Allocate memory from the ``struct gdbarch''
 314    obstack.  The memory is freed when the corresponding architecture
 315    is also freed.  */
 316
 317 #define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE)   obstack_calloc<TYPE> (gdbarch_obstack ((GDBARCH)), (NR))
 318
 319 #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE)   obstack_zalloc<TYPE> (gdbarch_obstack ((GDBARCH)))
 320
 321 /* Duplicate STRING, returning an equivalent string that's allocated on the
 322    obstack associated with GDBARCH.  The string is freed when the corresponding
 323    architecture is also freed.  */
 324
 325 extern char *gdbarch_obstack_strdup (struct gdbarch *arch, const char *string);
 326
 327 /* Helper function.  Force an update of the current architecture.
 328
 329    The actual architecture selected is determined by INFO, ``(gdb) set
 330    architecture'' et.al., the existing architecture and BFD's default
 331    architecture.  INFO should be initialized to zero and then selected
 332    fields should be updated.
 333
 334    Returns non-zero if the update succeeds.  */
 335
 336 extern int gdbarch_update_p (struct gdbarch_info info);
 337
 338
 339 /* Helper function.  Find an architecture matching info.
 340
 341    INFO should have relevant fields set, and then finished using
 342    gdbarch_info_fill.
 343
 344    Returns the corresponding architecture, or NULL if no matching
 345    architecture was found.  */
 346
 347 extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
 348
 349
 350 /* Helper function.  Set the target gdbarch to "gdbarch".  */
 351
 352 extern void set_target_gdbarch (struct gdbarch *gdbarch);
 353
 354
 355 /* A registry adaptor for gdbarch.  This arranges to store the
 356    registry in the gdbarch.  */
 357 template<>
 358 struct registry_accessor<gdbarch>
 359 {
 360   static registry<gdbarch> *get (gdbarch *arch);
 361 };
 362
 363 /* Set the dynamic target-system-dependent parameters (architecture,
 364    byte-order, ...) using information found in the BFD.  */
 365
 366 extern void set_gdbarch_from_file (bfd *);
 367
 368
 369 /* Initialize the current architecture to the "first" one we find on
 370    our list.  */
 371
 372 extern void initialize_current_architecture (void);
 373
 374 /* gdbarch trace variable */
 375 extern unsigned int gdbarch_debug;
 376
 377 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
 378
 379 /* Return the number of cooked registers (raw + pseudo) for ARCH.  */
 380
 381 static inline int
 382 gdbarch_num_cooked_regs (gdbarch *arch)
 383 {
 384   return gdbarch_num_regs (arch) + gdbarch_num_pseudo_regs (arch);
 385 }
 386
 387 #endif