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 /* 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