gdb/gdbarch.h

   1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
   2
   3 /* Dynamic architecture support for GDB, the GNU debugger.
   4
   5    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   6    2007, 2008, 2009 Free Software Foundation, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* This file was created with the aid of ``gdbarch.sh''.
  24
  25    The Bourne shell script ``gdbarch.sh'' creates the files
  26    ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
  27    against the existing ``gdbarch.[hc]''.  Any differences found
  28    being reported.
  29
  30    If editing this file, please also run gdbarch.sh and merge any
  31    changes into that script. Conversely, when making sweeping changes
  32    to this file, modifying gdbarch.sh and using its output may prove
  33    easier.  */
  34
  35 #ifndef GDBARCH_H
  36 #define GDBARCH_H
  37
  38 struct floatformat;
  39 struct ui_file;
  40 struct frame_info;
  41 struct value;
  42 struct objfile;
  43 struct obj_section;
  44 struct minimal_symbol;
  45 struct regcache;
  46 struct reggroup;
  47 struct regset;
  48 struct disassemble_info;
  49 struct target_ops;
  50 struct obstack;
  51 struct bp_target_info;
  52 struct target_desc;
  53 struct displaced_step_closure;
  54 struct core_regset_section;
  55 struct syscall;
  56 struct agent_expr;
  57 struct axs_value;
  58 struct stap_parse_info;
  59
  60 /* The architecture associated with the connection to the target.
  61
  62    The architecture vector provides some information that is really
  63    a property of the target: The layout of certain packets, for instance;
  64    or the solib_ops vector.  Etc.  To differentiate architecture accesses
  65    to per-target properties from per-thread/per-frame/per-objfile properties,
  66    accesses to per-target properties should be made through target_gdbarch.
  67
  68    Eventually, when support for multiple targets is implemented in
  69    GDB, this global should be made target-specific.  */
  70 extern struct gdbarch *target_gdbarch;
  71
  72 /* Callback type for the 'iterate_over_objfiles_in_search_order'
  73    gdbarch  method.  */
  74
  75 typedef int (iterate_over_objfiles_in_search_order_cb_ftype)
  76   (struct objfile *objfile, void *cb_data);
  77
  78
  79 /* The following are pre-initialized by GDBARCH.  */
  80
  81 extern const struct bfd_arch_info * gdbarch_bfd_arch_info (struct gdbarch *gdbarch);
  82 /* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized.  */
  83
  84 extern int gdbarch_byte_order (struct gdbarch *gdbarch);
  85 /* set_gdbarch_byte_order() - not applicable - pre-initialized.  */
  86
  87 extern int gdbarch_byte_order_for_code (struct gdbarch *gdbarch);
  88 /* set_gdbarch_byte_order_for_code() - not applicable - pre-initialized.  */
  89
  90 extern enum gdb_osabi gdbarch_osabi (struct gdbarch *gdbarch);
  91 /* set_gdbarch_osabi() - not applicable - pre-initialized.  */
  92
  93 extern const struct target_desc * gdbarch_target_desc (struct gdbarch *gdbarch);
  94 /* set_gdbarch_target_desc() - not applicable - pre-initialized.  */
  95
  96
  97 /* The following are initialized by the target dependent code.  */
  98
  99 /* The bit byte-order has to do just with numbering of bits in debugging symbols
 100    and such.  Conceptually, it's quite separate from byte/word byte order. */
 101
 102 extern int gdbarch_bits_big_endian (struct gdbarch *gdbarch);
 103 extern void set_gdbarch_bits_big_endian (struct gdbarch *gdbarch, int bits_big_endian);
 104
 105 /* Number of bits in a char or unsigned char for the target machine.
 106    Just like CHAR_BIT in <limits.h> but describes the target machine.
 107    v:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
 108
 109    Number of bits in a short or unsigned short for the target machine. */
 110
 111 extern int gdbarch_short_bit (struct gdbarch *gdbarch);
 112 extern void set_gdbarch_short_bit (struct gdbarch *gdbarch, int short_bit);
 113
 114 /* Number of bits in an int or unsigned int for the target machine. */
 115
 116 extern int gdbarch_int_bit (struct gdbarch *gdbarch);
 117 extern void set_gdbarch_int_bit (struct gdbarch *gdbarch, int int_bit);
 118
 119 /* Number of bits in a long or unsigned long for the target machine. */
 120
 121 extern int gdbarch_long_bit (struct gdbarch *gdbarch);
 122 extern void set_gdbarch_long_bit (struct gdbarch *gdbarch, int long_bit);
 123
 124 /* Number of bits in a long long or unsigned long long for the target
 125    machine. */
 126
 127 extern int gdbarch_long_long_bit (struct gdbarch *gdbarch);
 128 extern void set_gdbarch_long_long_bit (struct gdbarch *gdbarch, int long_long_bit);
 129
 130 /* Alignment of a long long or unsigned long long for the target
 131    machine. */
 132
 133 extern int gdbarch_long_long_align_bit (struct gdbarch *gdbarch);
 134 extern void set_gdbarch_long_long_align_bit (struct gdbarch *gdbarch, int long_long_align_bit);
 135
 136 /* The ABI default bit-size and format for "half", "float", "double", and
 137    "long double".  These bit/format pairs should eventually be combined
 138    into a single object.  For the moment, just initialize them as a pair.
 139    Each format describes both the big and little endian layouts (if
 140    useful). */
 141
 142 extern int gdbarch_half_bit (struct gdbarch *gdbarch);
 143 extern void set_gdbarch_half_bit (struct gdbarch *gdbarch, int half_bit);
 144
 145 extern const struct floatformat ** gdbarch_half_format (struct gdbarch *gdbarch);
 146 extern void set_gdbarch_half_format (struct gdbarch *gdbarch, const struct floatformat ** half_format);
 147
 148 extern int gdbarch_float_bit (struct gdbarch *gdbarch);
 149 extern void set_gdbarch_float_bit (struct gdbarch *gdbarch, int float_bit);
 150
 151 extern const struct floatformat ** gdbarch_float_format (struct gdbarch *gdbarch);
 152 extern void set_gdbarch_float_format (struct gdbarch *gdbarch, const struct floatformat ** float_format);
 153
 154 extern int gdbarch_double_bit (struct gdbarch *gdbarch);
 155 extern void set_gdbarch_double_bit (struct gdbarch *gdbarch, int double_bit);
 156
 157 extern const struct floatformat ** gdbarch_double_format (struct gdbarch *gdbarch);
 158 extern void set_gdbarch_double_format (struct gdbarch *gdbarch, const struct floatformat ** double_format);
 159
 160 extern int gdbarch_long_double_bit (struct gdbarch *gdbarch);
 161 extern void set_gdbarch_long_double_bit (struct gdbarch *gdbarch, int long_double_bit);
 162
 163 extern const struct floatformat ** gdbarch_long_double_format (struct gdbarch *gdbarch);
 164 extern void set_gdbarch_long_double_format (struct gdbarch *gdbarch, const struct floatformat ** long_double_format);
 165
 166 /* For most targets, a pointer on the target and its representation as an
 167    address in GDB have the same size and "look the same".  For such a
 168    target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
 169    / addr_bit will be set from it.
 170
 171    If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
 172    also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and
 173    gdbarch_address_to_pointer as well.
 174
 175    ptr_bit is the size of a pointer on the target */
 176
 177 extern int gdbarch_ptr_bit (struct gdbarch *gdbarch);
 178 extern void set_gdbarch_ptr_bit (struct gdbarch *gdbarch, int ptr_bit);
 179
 180 /* addr_bit is the size of a target address as represented in gdb */
 181
 182 extern int gdbarch_addr_bit (struct gdbarch *gdbarch);
 183 extern void set_gdbarch_addr_bit (struct gdbarch *gdbarch, int addr_bit);
 184
 185 /* dwarf2_addr_size is the target address size as used in the Dwarf debug
 186    info.  For .debug_frame FDEs, this is supposed to be the target address
 187    size from the associated CU header, and which is equivalent to the
 188    DWARF2_ADDR_SIZE as defined by the target specific GCC back-end.
 189    Unfortunately there is no good way to determine this value.  Therefore
 190    dwarf2_addr_size simply defaults to the target pointer size.
 191
 192    dwarf2_addr_size is not used for .eh_frame FDEs, which are generally
 193    defined using the target's pointer size so far.
 194
 195    Note that dwarf2_addr_size only needs to be redefined by a target if the
 196    GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size,
 197    and if Dwarf versions < 4 need to be supported. */
 198
 199 extern int gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch);
 200 extern void set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch, int dwarf2_addr_size);
 201
 202 /* One if `char' acts like `signed char', zero if `unsigned char'. */
 203
 204 extern int gdbarch_char_signed (struct gdbarch *gdbarch);
 205 extern void set_gdbarch_char_signed (struct gdbarch *gdbarch, int char_signed);
 206
 207 extern int gdbarch_read_pc_p (struct gdbarch *gdbarch);
 208
 209 typedef CORE_ADDR (gdbarch_read_pc_ftype) (struct regcache *regcache);
 210 extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache);
 211 extern void set_gdbarch_read_pc (struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc);
 212
 213 extern int gdbarch_write_pc_p (struct gdbarch *gdbarch);
 214
 215 typedef void (gdbarch_write_pc_ftype) (struct regcache *regcache, CORE_ADDR val);
 216 extern void gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val);
 217 extern void set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc);
 218
 219 /* Function for getting target's idea of a frame pointer.  FIXME: GDB's
 220    whole scheme for dealing with "frames" and "frame pointers" needs a
 221    serious shakedown. */
 222
 223 typedef void (gdbarch_virtual_frame_pointer_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset);
 224 extern void gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset);
 225 extern void set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer);
 226
 227 extern int gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch);
 228
 229 typedef enum register_status (gdbarch_pseudo_register_read_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf);
 230 extern enum register_status gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf);
 231 extern void set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read);
 232
 233 /* Read a register into a new struct value.  If the register is wholly
 234    or partly unavailable, this should call mark_value_bytes_unavailable
 235    as appropriate.  If this is defined, then pseudo_register_read will
 236    never be called. */
 237
 238 extern int gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch);
 239
 240 typedef struct value * (gdbarch_pseudo_register_read_value_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum);
 241 extern struct value * gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum);
 242 extern void set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value);
 243
 244 extern int gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch);
 245
 246 typedef void (gdbarch_pseudo_register_write_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf);
 247 extern void gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf);
 248 extern void set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write);
 249
 250 extern int gdbarch_num_regs (struct gdbarch *gdbarch);
 251 extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs);
 252
 253 /* This macro gives the number of pseudo-registers that live in the
 254    register namespace but do not get fetched or stored on the target.
 255    These pseudo-registers may be aliases for other registers,
 256    combinations of other registers, or they may be computed by GDB. */
 257
 258 extern int gdbarch_num_pseudo_regs (struct gdbarch *gdbarch);
 259 extern void set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, int num_pseudo_regs);
 260
 261 /* Assemble agent expression bytecode to collect pseudo-register REG.
 262    Return -1 if something goes wrong, 0 otherwise. */
 263
 264 extern int gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch);
 265
 266 typedef int (gdbarch_ax_pseudo_register_collect_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
 267 extern int gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
 268 extern void set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect);
 269
 270 /* Assemble agent expression bytecode to push the value of pseudo-register
 271    REG on the interpreter stack.
 272    Return -1 if something goes wrong, 0 otherwise. */
 273
 274 extern int gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch);
 275
 276 typedef int (gdbarch_ax_pseudo_register_push_stack_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
 277 extern int gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
 278 extern void set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack);
 279
 280 /* GDB's standard (or well known) register numbers.  These can map onto
 281    a real register or a pseudo (computed) register or not be defined at
 282    all (-1).
 283    gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP. */
 284
 285 extern int gdbarch_sp_regnum (struct gdbarch *gdbarch);
 286 extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum);
 287
 288 extern int gdbarch_pc_regnum (struct gdbarch *gdbarch);
 289 extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum);
 290
 291 extern int gdbarch_ps_regnum (struct gdbarch *gdbarch);
 292 extern void set_gdbarch_ps_regnum (struct gdbarch *gdbarch, int ps_regnum);
 293
 294 extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch);
 295 extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum);
 296
 297 /* Convert stab register number (from `r' declaration) to a gdb REGNUM. */
 298
 299 typedef int (gdbarch_stab_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int stab_regnr);
 300 extern int gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr);
 301 extern void set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum);
 302
 303 /* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
 304
 305 typedef int (gdbarch_ecoff_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int ecoff_regnr);
 306 extern int gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr);
 307 extern void set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum);
 308
 309 /* Convert from an sdb register number to an internal gdb register number. */
 310
 311 typedef int (gdbarch_sdb_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int sdb_regnr);
 312 extern int gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr);
 313 extern void set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum);
 314
 315 /* Provide a default mapping from a DWARF2 register number to a gdb REGNUM. */
 316
 317 typedef int (gdbarch_dwarf2_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int dwarf2_regnr);
 318 extern int gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr);
 319 extern void set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum);
 320
 321 typedef const char * (gdbarch_register_name_ftype) (struct gdbarch *gdbarch, int regnr);
 322 extern const char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr);
 323 extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name);
 324
 325 /* Return the type of a register specified by the architecture.  Only
 326    the register cache should call this function directly; others should
 327    use "register_type". */
 328
 329 extern int gdbarch_register_type_p (struct gdbarch *gdbarch);
 330
 331 typedef struct type * (gdbarch_register_type_ftype) (struct gdbarch *gdbarch, int reg_nr);
 332 extern struct type * gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr);
 333 extern void set_gdbarch_register_type (struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type);
 334
 335 /* See gdbint.texinfo, and PUSH_DUMMY_CALL. */
 336
 337 extern int gdbarch_dummy_id_p (struct gdbarch *gdbarch);
 338
 339 typedef struct frame_id (gdbarch_dummy_id_ftype) (struct gdbarch *gdbarch, struct frame_info *this_frame);
 340 extern struct frame_id gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame);
 341 extern void set_gdbarch_dummy_id (struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id);
 342
 343 /* Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
 344    deprecated_fp_regnum. */
 345
 346 extern int gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch);
 347 extern void set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch, int deprecated_fp_regnum);
 348
 349 /* See gdbint.texinfo.  See infcall.c. */
 350
 351 extern int gdbarch_push_dummy_call_p (struct gdbarch *gdbarch);
 352
 353 typedef CORE_ADDR (gdbarch_push_dummy_call_ftype) (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
 354 extern CORE_ADDR gdbarch_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
 355 extern void set_gdbarch_push_dummy_call (struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call);
 356
 357 extern int gdbarch_call_dummy_location (struct gdbarch *gdbarch);
 358 extern void set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, int call_dummy_location);
 359
 360 extern int gdbarch_push_dummy_code_p (struct gdbarch *gdbarch);
 361
 362 typedef CORE_ADDR (gdbarch_push_dummy_code_ftype) (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache);
 363 extern CORE_ADDR gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache);
 364 extern void set_gdbarch_push_dummy_code (struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype *push_dummy_code);
 365
 366 typedef void (gdbarch_print_registers_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
 367 extern void gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
 368 extern void set_gdbarch_print_registers_info (struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype *print_registers_info);
 369
 370 extern int gdbarch_print_float_info_p (struct gdbarch *gdbarch);
 371
 372 typedef void (gdbarch_print_float_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
 373 extern void gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
 374 extern void set_gdbarch_print_float_info (struct gdbarch *gdbarch, gdbarch_print_float_info_ftype *print_float_info);
 375
 376 extern int gdbarch_print_vector_info_p (struct gdbarch *gdbarch);
 377
 378 typedef void (gdbarch_print_vector_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
 379 extern void gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
 380 extern void set_gdbarch_print_vector_info (struct gdbarch *gdbarch, gdbarch_print_vector_info_ftype *print_vector_info);
 381
 382 /* MAP a GDB RAW register number onto a simulator register number.  See
 383    also include/...-sim.h. */
 384
 385 typedef int (gdbarch_register_sim_regno_ftype) (struct gdbarch *gdbarch, int reg_nr);
 386 extern int gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr);
 387 extern void set_gdbarch_register_sim_regno (struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype *register_sim_regno);
 388
 389 typedef int (gdbarch_cannot_fetch_register_ftype) (struct gdbarch *gdbarch, int regnum);
 390 extern int gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum);
 391 extern void set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, gdbarch_cannot_fetch_register_ftype *cannot_fetch_register);
 392
 393 typedef int (gdbarch_cannot_store_register_ftype) (struct gdbarch *gdbarch, int regnum);
 394 extern int gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum);
 395 extern void set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype *cannot_store_register);
 396
 397 /* setjmp/longjmp support. */
 398
 399 extern int gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch);
 400
 401 typedef int (gdbarch_get_longjmp_target_ftype) (struct frame_info *frame, CORE_ADDR *pc);
 402 extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc);
 403 extern void set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target);
 404
 405 extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch);
 406 extern void set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, int believe_pcc_promotion);
 407
 408 typedef int (gdbarch_convert_register_p_ftype) (struct gdbarch *gdbarch, int regnum, struct type *type);
 409 extern int gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type);
 410 extern void set_gdbarch_convert_register_p (struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype *convert_register_p);
 411
 412 typedef int (gdbarch_register_to_value_ftype) (struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
 413 extern int gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
 414 extern void set_gdbarch_register_to_value (struct gdbarch *gdbarch, gdbarch_register_to_value_ftype *register_to_value);
 415
 416 typedef void (gdbarch_value_to_register_ftype) (struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf);
 417 extern void gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf);
 418 extern void set_gdbarch_value_to_register (struct gdbarch *gdbarch, gdbarch_value_to_register_ftype *value_to_register);
 419
 420 /* Construct a value representing the contents of register REGNUM in
 421    frame FRAME, interpreted as type TYPE.  The routine needs to
 422    allocate and return a struct value with all value attributes
 423    (but not the value contents) filled in. */
 424
 425 typedef struct value * (gdbarch_value_from_register_ftype) (struct type *type, int regnum, struct frame_info *frame);
 426 extern struct value * gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame);
 427 extern void set_gdbarch_value_from_register (struct gdbarch *gdbarch, gdbarch_value_from_register_ftype *value_from_register);
 428
 429 typedef CORE_ADDR (gdbarch_pointer_to_address_ftype) (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
 430 extern CORE_ADDR gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
 431 extern void set_gdbarch_pointer_to_address (struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address);
 432
 433 typedef void (gdbarch_address_to_pointer_ftype) (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr);
 434 extern void gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr);
 435 extern void set_gdbarch_address_to_pointer (struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer);
 436
 437 extern int gdbarch_integer_to_address_p (struct gdbarch *gdbarch);
 438
 439 typedef CORE_ADDR (gdbarch_integer_to_address_ftype) (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
 440 extern CORE_ADDR gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
 441 extern void set_gdbarch_integer_to_address (struct gdbarch *gdbarch, gdbarch_integer_to_address_ftype *integer_to_address);
 442
 443 /* Return the return-value convention that will be used by FUNCTION
 444    to return a value of type VALTYPE.  FUNCTION may be NULL in which
 445    case the return convention is computed based only on VALTYPE.
 446
 447    If READBUF is not NULL, extract the return value and save it in this buffer.
 448
 449    If WRITEBUF is not NULL, it contains a return value which will be
 450    stored into the appropriate register.  This can be used when we want
 451    to force the value returned by a function (see the "return" command
 452    for instance). */
 453
 454 extern int gdbarch_return_value_p (struct gdbarch *gdbarch);
 455
 456 typedef enum return_value_convention (gdbarch_return_value_ftype) (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf);
 457 extern enum return_value_convention gdbarch_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf);
 458 extern void set_gdbarch_return_value (struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value);
 459
 460 typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
 461 extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
 462 extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue);
 463
 464 extern int gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch);
 465
 466 typedef CORE_ADDR (gdbarch_skip_main_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
 467 extern CORE_ADDR gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
 468 extern void set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype *skip_main_prologue);
 469
 470 typedef int (gdbarch_inner_than_ftype) (CORE_ADDR lhs, CORE_ADDR rhs);
 471 extern int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs);
 472 extern void set_gdbarch_inner_than (struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than);
 473
 474 typedef const gdb_byte * (gdbarch_breakpoint_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
 475 extern const gdb_byte * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
 476 extern void set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc);
 477
 478 /* Return the adjusted address and kind to use for Z0/Z1 packets.
 479    KIND is usually the memory length of the breakpoint, but may have a
 480    different target-specific meaning. */
 481
 482 typedef void (gdbarch_remote_breakpoint_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr);
 483 extern void gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr);
 484 extern void set_gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_remote_breakpoint_from_pc_ftype *remote_breakpoint_from_pc);
 485
 486 extern int gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch);
 487
 488 typedef CORE_ADDR (gdbarch_adjust_breakpoint_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
 489 extern CORE_ADDR gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
 490 extern void set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address);
 491
 492 typedef int (gdbarch_memory_insert_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
 493 extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
 494 extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint);
 495
 496 typedef int (gdbarch_memory_remove_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
 497 extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
 498 extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint);
 499
 500 extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch);
 501 extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break);
 502
 503 /* A function can be addressed by either it's "pointer" (possibly a
 504    descriptor address) or "entry point" (first executable instruction).
 505    The method "convert_from_func_ptr_addr" converting the former to the
 506    latter.  gdbarch_deprecated_function_start_offset is being used to implement
 507    a simplified subset of that functionality - the function's address
 508    corresponds to the "function pointer" and the function's start
 509    corresponds to the "function entry point" - and hence is redundant. */
 510
 511 extern CORE_ADDR gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch);
 512 extern void set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_function_start_offset);
 513
 514 /* Return the remote protocol register number associated with this
 515    register.  Normally the identity mapping. */
 516
 517 typedef int (gdbarch_remote_register_number_ftype) (struct gdbarch *gdbarch, int regno);
 518 extern int gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno);
 519 extern void set_gdbarch_remote_register_number (struct gdbarch *gdbarch, gdbarch_remote_register_number_ftype *remote_register_number);
 520
 521 /* Fetch the target specific address used to represent a load module. */
 522
 523 extern int gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch);
 524
 525 typedef CORE_ADDR (gdbarch_fetch_tls_load_module_address_ftype) (struct objfile *objfile);
 526 extern CORE_ADDR gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile);
 527 extern void set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address);
 528
 529 extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
 530 extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
 531
 532 extern int gdbarch_unwind_pc_p (struct gdbarch *gdbarch);
 533
 534 typedef CORE_ADDR (gdbarch_unwind_pc_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
 535 extern CORE_ADDR gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame);
 536 extern void set_gdbarch_unwind_pc (struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype *unwind_pc);
 537
 538 extern int gdbarch_unwind_sp_p (struct gdbarch *gdbarch);
 539
 540 typedef CORE_ADDR (gdbarch_unwind_sp_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
 541 extern CORE_ADDR gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame);
 542 extern void set_gdbarch_unwind_sp (struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype *unwind_sp);
 543
 544 /* DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
 545    frame-base.  Enable frame-base before frame-unwind. */
 546
 547 extern int gdbarch_frame_num_args_p (struct gdbarch *gdbarch);
 548
 549 typedef int (gdbarch_frame_num_args_ftype) (struct frame_info *frame);
 550 extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame);
 551 extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args);
 552
 553 extern int gdbarch_frame_align_p (struct gdbarch *gdbarch);
 554
 555 typedef CORE_ADDR (gdbarch_frame_align_ftype) (struct gdbarch *gdbarch, CORE_ADDR address);
 556 extern CORE_ADDR gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address);
 557 extern void set_gdbarch_frame_align (struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align);
 558
 559 typedef int (gdbarch_stabs_argument_has_addr_ftype) (struct gdbarch *gdbarch, struct type *type);
 560 extern int gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type);
 561 extern void set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr);
 562
 563 extern int gdbarch_frame_red_zone_size (struct gdbarch *gdbarch);
 564 extern void set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch, int frame_red_zone_size);
 565
 566 typedef CORE_ADDR (gdbarch_convert_from_func_ptr_addr_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ);
 567 extern CORE_ADDR gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ);
 568 extern void set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr);
 569
 570 /* On some machines there are bits in addresses which are not really
 571    part of the address, but are used by the kernel, the hardware, etc.
 572    for special purposes.  gdbarch_addr_bits_remove takes out any such bits so
 573    we get a "real" address such as one would find in a symbol table.
 574    This is used only for addresses of instructions, and even then I'm
 575    not sure it's used in all contexts.  It exists to deal with there
 576    being a few stray bits in the PC which would mislead us, not as some
 577    sort of generic thing to handle alignment or segmentation (it's
 578    possible it should be in TARGET_READ_PC instead). */
 579
 580 typedef CORE_ADDR (gdbarch_addr_bits_remove_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
 581 extern CORE_ADDR gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr);
 582 extern void set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype *addr_bits_remove);
 583
 584 /* It is not at all clear why gdbarch_smash_text_address is not folded into
 585    gdbarch_addr_bits_remove. */
 586
 587 typedef CORE_ADDR (gdbarch_smash_text_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
 588 extern CORE_ADDR gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr);
 589 extern void set_gdbarch_smash_text_address (struct gdbarch *gdbarch, gdbarch_smash_text_address_ftype *smash_text_address);
 590
 591 /* FIXME/cagney/2001-01-18: This should be split in two.  A target method that
 592    indicates if the target needs software single step.  An ISA method to
 593    implement it.
 594
 595    FIXME/cagney/2001-01-18: This should be replaced with something that inserts
 596    breakpoints using the breakpoint system instead of blatting memory directly
 597    (as with rs6000).
 598
 599    FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the
 600    target can single step.  If not, then implement single step using breakpoints.
 601
 602    A return value of 1 means that the software_single_step breakpoints
 603    were inserted; 0 means they were not. */
 604
 605 extern int gdbarch_software_single_step_p (struct gdbarch *gdbarch);
 606
 607 typedef int (gdbarch_software_single_step_ftype) (struct frame_info *frame);
 608 extern int gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame);
 609 extern void set_gdbarch_software_single_step (struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step);
 610
 611 /* Return non-zero if the processor is executing a delay slot and a
 612    further single-step is needed before the instruction finishes. */
 613
 614 extern int gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch);
 615
 616 typedef int (gdbarch_single_step_through_delay_ftype) (struct gdbarch *gdbarch, struct frame_info *frame);
 617 extern int gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame);
 618 extern void set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch, gdbarch_single_step_through_delay_ftype *single_step_through_delay);
 619
 620 /* FIXME: cagney/2003-08-28: Need to find a better way of selecting the
 621    disassembler.  Perhaps objdump can handle it? */
 622
 623 typedef int (gdbarch_print_insn_ftype) (bfd_vma vma, struct disassemble_info *info);
 624 extern int gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info);
 625 extern void set_gdbarch_print_insn (struct gdbarch *gdbarch, gdbarch_print_insn_ftype *print_insn);
 626
 627 typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (struct frame_info *frame, CORE_ADDR pc);
 628 extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc);
 629 extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code);
 630
 631 /* If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER
 632    evaluates non-zero, this is the address where the debugger will place
 633    a step-resume breakpoint to get us past the dynamic linker. */
 634
 635 typedef CORE_ADDR (gdbarch_skip_solib_resolver_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc);
 636 extern CORE_ADDR gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc);
 637 extern void set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype *skip_solib_resolver);
 638
 639 /* Some systems also have trampoline code for returning from shared libs. */
 640
 641 typedef int (gdbarch_in_solib_return_trampoline_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name);
 642 extern int gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name);
 643 extern void set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline);
 644
 645 /* A target might have problems with watchpoints as soon as the stack
 646    frame of the current function has been destroyed.  This mostly happens
 647    as the first action in a funtion's epilogue.  in_function_epilogue_p()
 648    is defined to return a non-zero value if either the given addr is one
 649    instruction after the stack destroying instruction up to the trailing
 650    return instruction or if we can figure out that the stack frame has
 651    already been invalidated regardless of the value of addr.  Targets
 652    which don't suffer from that problem could just let this functionality
 653    untouched. */
 654
 655 typedef int (gdbarch_in_function_epilogue_p_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
 656 extern int gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr);
 657 extern void set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p);
 658
 659 typedef void (gdbarch_elf_make_msymbol_special_ftype) (asymbol *sym, struct minimal_symbol *msym);
 660 extern void gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym);
 661 extern void set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special);
 662
 663 typedef void (gdbarch_coff_make_msymbol_special_ftype) (int val, struct minimal_symbol *msym);
 664 extern void gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym);
 665 extern void set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special);
 666
 667 extern int gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch);
 668 extern void set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, int cannot_step_breakpoint);
 669
 670 extern int gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch);
 671 extern void set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, int have_nonsteppable_watchpoint);
 672
 673 extern int gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch);
 674
 675 typedef int (gdbarch_address_class_type_flags_ftype) (int byte_size, int dwarf2_addr_class);
 676 extern int gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class);
 677 extern void set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags);
 678
 679 extern int gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch);
 680
 681 typedef const char * (gdbarch_address_class_type_flags_to_name_ftype) (struct gdbarch *gdbarch, int type_flags);
 682 extern const char * gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags);
 683 extern void set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name);
 684
 685 extern int gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch);
 686
 687 typedef int (gdbarch_address_class_name_to_type_flags_ftype) (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
 688 extern int gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
 689 extern void set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags);
 690
 691 /* Is a register in a group */
 692
 693 typedef int (gdbarch_register_reggroup_p_ftype) (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
 694 extern int gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
 695 extern void set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p);
 696
 697 /* Fetch the pointer to the ith function argument. */
 698
 699 extern int gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch);
 700
 701 typedef CORE_ADDR (gdbarch_fetch_pointer_argument_ftype) (struct frame_info *frame, int argi, struct type *type);
 702 extern CORE_ADDR gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type);
 703 extern void set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument);
 704
 705 /* Return the appropriate register set for a core file section with
 706    name SECT_NAME and size SECT_SIZE. */
 707
 708 extern int gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch);
 709
 710 typedef const struct regset * (gdbarch_regset_from_core_section_ftype) (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size);
 711 extern const struct regset * gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size);
 712 extern void set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch, gdbarch_regset_from_core_section_ftype *regset_from_core_section);
 713
 714 /* Supported register notes in a core file. */
 715
 716 extern struct core_regset_section * gdbarch_core_regset_sections (struct gdbarch *gdbarch);
 717 extern void set_gdbarch_core_regset_sections (struct gdbarch *gdbarch, struct core_regset_section * core_regset_sections);
 718
 719 /* Create core file notes */
 720
 721 extern int gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch);
 722
 723 typedef char * (gdbarch_make_corefile_notes_ftype) (struct gdbarch *gdbarch, bfd *obfd, int *note_size);
 724 extern char * gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size);
 725 extern void set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch, gdbarch_make_corefile_notes_ftype *make_corefile_notes);
 726
 727 /* Find core file memory regions */
 728
 729 extern int gdbarch_find_memory_regions_p (struct gdbarch *gdbarch);
 730
 731 typedef int (gdbarch_find_memory_regions_ftype) (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data);
 732 extern int gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data);
 733 extern void set_gdbarch_find_memory_regions (struct gdbarch *gdbarch, gdbarch_find_memory_regions_ftype *find_memory_regions);
 734
 735 /* Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
 736    core file into buffer READBUF with length LEN. */
 737
 738 extern int gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch);
 739
 740 typedef LONGEST (gdbarch_core_xfer_shared_libraries_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len);
 741 extern LONGEST gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len);
 742 extern void set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries);
 743
 744 /* How the core target converts a PTID from a core file to a string. */
 745
 746 extern int gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch);
 747
 748 typedef char * (gdbarch_core_pid_to_str_ftype) (struct gdbarch *gdbarch, ptid_t ptid);
 749 extern char * gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid);
 750 extern void set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch, gdbarch_core_pid_to_str_ftype *core_pid_to_str);
 751
 752 /* BFD target to use when generating a core file. */
 753
 754 extern int gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch);
 755
 756 extern const char * gdbarch_gcore_bfd_target (struct gdbarch *gdbarch);
 757 extern void set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch, const char * gcore_bfd_target);
 758
 759 /* If the elements of C++ vtables are in-place function descriptors rather
 760    than normal function pointers (which may point to code or a descriptor),
 761    set this to one. */
 762
 763 extern int gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch);
 764 extern void set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch, int vtable_function_descriptors);
 765
 766 /* Set if the least significant bit of the delta is used instead of the least
 767    significant bit of the pfn for pointers to virtual member functions. */
 768
 769 extern int gdbarch_vbit_in_delta (struct gdbarch *gdbarch);
 770 extern void set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch, int vbit_in_delta);
 771
 772 /* Advance PC to next instruction in order to skip a permanent breakpoint. */
 773
 774 extern int gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch);
 775
 776 typedef void (gdbarch_skip_permanent_breakpoint_ftype) (struct regcache *regcache);
 777 extern void gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache);
 778 extern void set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint);
 779
 780 /* The maximum length of an instruction on this architecture in bytes. */
 781
 782 extern int gdbarch_max_insn_length_p (struct gdbarch *gdbarch);
 783
 784 extern ULONGEST gdbarch_max_insn_length (struct gdbarch *gdbarch);
 785 extern void set_gdbarch_max_insn_length (struct gdbarch *gdbarch, ULONGEST max_insn_length);
 786
 787 /* Copy the instruction at FROM to TO, and make any adjustments
 788    necessary to single-step it at that address.
 789
 790    REGS holds the state the thread's registers will have before
 791    executing the copied instruction; the PC in REGS will refer to FROM,
 792    not the copy at TO.  The caller should update it to point at TO later.
 793
 794    Return a pointer to data of the architecture's choice to be passed
 795    to gdbarch_displaced_step_fixup.  Or, return NULL to indicate that
 796    the instruction's effects have been completely simulated, with the
 797    resulting state written back to REGS.
 798
 799    For a general explanation of displaced stepping and how GDB uses it,
 800    see the comments in infrun.c.
 801
 802    The TO area is only guaranteed to have space for
 803    gdbarch_max_insn_length (arch) bytes, so this function must not
 804    write more bytes than that to that area.
 805
 806    If you do not provide this function, GDB assumes that the
 807    architecture does not support displaced stepping.
 808
 809    If your architecture doesn't need to adjust instructions before
 810    single-stepping them, consider using simple_displaced_step_copy_insn
 811    here. */
 812
 813 extern int gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch);
 814
 815 typedef struct displaced_step_closure * (gdbarch_displaced_step_copy_insn_ftype) (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
 816 extern struct displaced_step_closure * gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
 817 extern void set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn);
 818
 819 /* Return true if GDB should use hardware single-stepping to execute
 820    the displaced instruction identified by CLOSURE.  If false,
 821    GDB will simply restart execution at the displaced instruction
 822    location, and it is up to the target to ensure GDB will receive
 823    control again (e.g. by placing a software breakpoint instruction
 824    into the displaced instruction buffer).
 825
 826    The default implementation returns false on all targets that
 827    provide a gdbarch_software_single_step routine, and true otherwise. */
 828
 829 typedef int (gdbarch_displaced_step_hw_singlestep_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
 830 extern int gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
 831 extern void set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep);
 832
 833 /* Fix up the state resulting from successfully single-stepping a
 834    displaced instruction, to give the result we would have gotten from
 835    stepping the instruction in its original location.
 836
 837    REGS is the register state resulting from single-stepping the
 838    displaced instruction.
 839
 840    CLOSURE is the result from the matching call to
 841    gdbarch_displaced_step_copy_insn.
 842
 843    If you provide gdbarch_displaced_step_copy_insn.but not this
 844    function, then GDB assumes that no fixup is needed after
 845    single-stepping the instruction.
 846
 847    For a general explanation of displaced stepping and how GDB uses it,
 848    see the comments in infrun.c. */
 849
 850 extern int gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch);
 851
 852 typedef void (gdbarch_displaced_step_fixup_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
 853 extern void gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
 854 extern void set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype *displaced_step_fixup);
 855
 856 /* Free a closure returned by gdbarch_displaced_step_copy_insn.
 857
 858    If you provide gdbarch_displaced_step_copy_insn, you must provide
 859    this function as well.
 860
 861    If your architecture uses closures that don't need to be freed, then
 862    you can use simple_displaced_step_free_closure here.
 863
 864    For a general explanation of displaced stepping and how GDB uses it,
 865    see the comments in infrun.c. */
 866
 867 typedef void (gdbarch_displaced_step_free_closure_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
 868 extern void gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
 869 extern void set_gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, gdbarch_displaced_step_free_closure_ftype *displaced_step_free_closure);
 870
 871 /* Return the address of an appropriate place to put displaced
 872    instructions while we step over them.  There need only be one such
 873    place, since we're only stepping one thread over a breakpoint at a
 874    time.
 875
 876    For a general explanation of displaced stepping and how GDB uses it,
 877    see the comments in infrun.c. */
 878
 879 typedef CORE_ADDR (gdbarch_displaced_step_location_ftype) (struct gdbarch *gdbarch);
 880 extern CORE_ADDR gdbarch_displaced_step_location (struct gdbarch *gdbarch);
 881 extern void set_gdbarch_displaced_step_location (struct gdbarch *gdbarch, gdbarch_displaced_step_location_ftype *displaced_step_location);
 882
 883 /* Relocate an instruction to execute at a different address.  OLDLOC
 884    is the address in the inferior memory where the instruction to
 885    relocate is currently at.  On input, TO points to the destination
 886    where we want the instruction to be copied (and possibly adjusted)
 887    to.  On output, it points to one past the end of the resulting
 888    instruction(s).  The effect of executing the instruction at TO shall
 889    be the same as if executing it at FROM.  For example, call
 890    instructions that implicitly push the return address on the stack
 891    should be adjusted to return to the instruction after OLDLOC;
 892    relative branches, and other PC-relative instructions need the
 893    offset adjusted; etc. */
 894
 895 extern int gdbarch_relocate_instruction_p (struct gdbarch *gdbarch);
 896
 897 typedef void (gdbarch_relocate_instruction_ftype) (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from);
 898 extern void gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from);
 899 extern void set_gdbarch_relocate_instruction (struct gdbarch *gdbarch, gdbarch_relocate_instruction_ftype *relocate_instruction);
 900
 901 /* Refresh overlay mapped state for section OSECT. */
 902
 903 extern int gdbarch_overlay_update_p (struct gdbarch *gdbarch);
 904
 905 typedef void (gdbarch_overlay_update_ftype) (struct obj_section *osect);
 906 extern void gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect);
 907 extern void set_gdbarch_overlay_update (struct gdbarch *gdbarch, gdbarch_overlay_update_ftype *overlay_update);
 908
 909 extern int gdbarch_core_read_description_p (struct gdbarch *gdbarch);
 910
 911 typedef const struct target_desc * (gdbarch_core_read_description_ftype) (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
 912 extern const struct target_desc * gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
 913 extern void set_gdbarch_core_read_description (struct gdbarch *gdbarch, gdbarch_core_read_description_ftype *core_read_description);
 914
 915 /* Handle special encoding of static variables in stabs debug info. */
 916
 917 extern int gdbarch_static_transform_name_p (struct gdbarch *gdbarch);
 918
 919 typedef const char * (gdbarch_static_transform_name_ftype) (const char *name);
 920 extern const char * gdbarch_static_transform_name (struct gdbarch *gdbarch, const char *name);
 921 extern void set_gdbarch_static_transform_name (struct gdbarch *gdbarch, gdbarch_static_transform_name_ftype *static_transform_name);
 922
 923 /* Set if the address in N_SO or N_FUN stabs may be zero. */
 924
 925 extern int gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch);
 926 extern void set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch, int sofun_address_maybe_missing);
 927
 928 /* Parse the instruction at ADDR storing in the record execution log
 929    the registers REGCACHE and memory ranges that will be affected when
 930    the instruction executes, along with their current values.
 931    Return -1 if something goes wrong, 0 otherwise. */
 932
 933 extern int gdbarch_process_record_p (struct gdbarch *gdbarch);
 934
 935 typedef int (gdbarch_process_record_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
 936 extern int gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
 937 extern void set_gdbarch_process_record (struct gdbarch *gdbarch, gdbarch_process_record_ftype *process_record);
 938
 939 /* Save process state after a signal.
 940    Return -1 if something goes wrong, 0 otherwise. */
 941
 942 extern int gdbarch_process_record_signal_p (struct gdbarch *gdbarch);
 943
 944 typedef int (gdbarch_process_record_signal_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal);
 945 extern int gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal);
 946 extern void set_gdbarch_process_record_signal (struct gdbarch *gdbarch, gdbarch_process_record_signal_ftype *process_record_signal);
 947
 948 /* Signal translation: translate inferior's signal (target's) number
 949    into GDB's representation.  The implementation of this method must
 950    be host independent.  IOW, don't rely on symbols of the NAT_FILE
 951    header (the nm-*.h files), the host <signal.h> header, or similar
 952    headers.  This is mainly used when cross-debugging core files ---
 953    "Live" targets hide the translation behind the target interface
 954    (target_wait, target_resume, etc.). */
 955
 956 extern int gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch);
 957
 958 typedef enum gdb_signal (gdbarch_gdb_signal_from_target_ftype) (struct gdbarch *gdbarch, int signo);
 959 extern enum gdb_signal gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, int signo);
 960 extern void set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target);
 961
 962 /* Extra signal info inspection.
 963
 964    Return a type suitable to inspect extra signal information. */
 965
 966 extern int gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch);
 967
 968 typedef struct type * (gdbarch_get_siginfo_type_ftype) (struct gdbarch *gdbarch);
 969 extern struct type * gdbarch_get_siginfo_type (struct gdbarch *gdbarch);
 970 extern void set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch, gdbarch_get_siginfo_type_ftype *get_siginfo_type);
 971
 972 /* Record architecture-specific information from the symbol table. */
 973
 974 extern int gdbarch_record_special_symbol_p (struct gdbarch *gdbarch);
 975
 976 typedef void (gdbarch_record_special_symbol_ftype) (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym);
 977 extern void gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym);
 978 extern void set_gdbarch_record_special_symbol (struct gdbarch *gdbarch, gdbarch_record_special_symbol_ftype *record_special_symbol);
 979
 980 /* Function for the 'catch syscall' feature.
 981    Get architecture-specific system calls information from registers. */
 982
 983 extern int gdbarch_get_syscall_number_p (struct gdbarch *gdbarch);
 984
 985 typedef LONGEST (gdbarch_get_syscall_number_ftype) (struct gdbarch *gdbarch, ptid_t ptid);
 986 extern LONGEST gdbarch_get_syscall_number (struct gdbarch *gdbarch, ptid_t ptid);
 987 extern void set_gdbarch_get_syscall_number (struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype *get_syscall_number);
 988
 989 /* SystemTap related fields and functions.
 990    Prefix used to mark an integer constant on the architecture's assembly
 991    For example, on x86 integer constants are written as:
 992
 993     $10 ;; integer constant 10
 994
 995    in this case, this prefix would be the character `$'. */
 996
 997 extern const char * gdbarch_stap_integer_prefix (struct gdbarch *gdbarch);
 998 extern void set_gdbarch_stap_integer_prefix (struct gdbarch *gdbarch, const char * stap_integer_prefix);
 999
1000 /* Suffix used to mark an integer constant on the architecture's assembly. */
1001
1002 extern const char * gdbarch_stap_integer_suffix (struct gdbarch *gdbarch);
1003 extern void set_gdbarch_stap_integer_suffix (struct gdbarch *gdbarch, const char * stap_integer_suffix);
1004
1005 /* Prefix used to mark a register name on the architecture's assembly.
1006    For example, on x86 the register name is written as:
1007
1008     %eax ;; register eax
1009
1010    in this case, this prefix would be the character `%'. */
1011
1012 extern const char * gdbarch_stap_register_prefix (struct gdbarch *gdbarch);
1013 extern void set_gdbarch_stap_register_prefix (struct gdbarch *gdbarch, const char * stap_register_prefix);
1014
1015 /* Suffix used to mark a register name on the architecture's assembly */
1016
1017 extern const char * gdbarch_stap_register_suffix (struct gdbarch *gdbarch);
1018 extern void set_gdbarch_stap_register_suffix (struct gdbarch *gdbarch, const char * stap_register_suffix);
1019
1020 /* Prefix used to mark a register indirection on the architecture's assembly.
1021    For example, on x86 the register indirection is written as:
1022
1023     (%eax) ;; indirecting eax
1024
1025    in this case, this prefix would be the charater `('.
1026
1027    Please note that we use the indirection prefix also for register
1028    displacement, e.g., `4(%eax)' on x86. */
1029
1030 extern const char * gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch);
1031 extern void set_gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch, const char * stap_register_indirection_prefix);
1032
1033 /* Suffix used to mark a register indirection on the architecture's assembly.
1034    For example, on x86 the register indirection is written as:
1035
1036     (%eax) ;; indirecting eax
1037
1038    in this case, this prefix would be the charater `)'.
1039
1040    Please note that we use the indirection suffix also for register
1041    displacement, e.g., `4(%eax)' on x86. */
1042
1043 extern const char * gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch);
1044 extern void set_gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch, const char * stap_register_indirection_suffix);
1045
1046 /* Prefix used to name a register using GDB's nomenclature.
1047
1048    For example, on PPC a register is represented by a number in the assembly
1049    language (e.g., `10' is the 10th general-purpose register).  However,
1050    inside GDB this same register has an `r' appended to its name, so the 10th
1051    register would be represented as `r10' internally. */
1052
1053 extern const char * gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch);
1054 extern void set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch, const char * stap_gdb_register_prefix);
1055
1056 /* Suffix used to name a register using GDB's nomenclature. */
1057
1058 extern const char * gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch);
1059 extern void set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch, const char * stap_gdb_register_suffix);
1060
1061 /* Check if S is a single operand.
1062
1063    Single operands can be:
1064     - Literal integers, e.g. `$10' on x86
1065     - Register access, e.g. `%eax' on x86
1066     - Register indirection, e.g. `(%eax)' on x86
1067     - Register displacement, e.g. `4(%eax)' on x86
1068
1069    This function should check for these patterns on the string
1070    and return 1 if some were found, or zero otherwise.  Please try to match
1071    as much info as you can from the string, i.e., if you have to match
1072    something like `(%', do not match just the `('. */
1073
1074 extern int gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch);
1075
1076 typedef int (gdbarch_stap_is_single_operand_ftype) (struct gdbarch *gdbarch, const char *s);
1077 extern int gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s);
1078 extern void set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand);
1079
1080 /* Function used to handle a "special case" in the parser.
1081
1082    A "special case" is considered to be an unknown token, i.e., a token
1083    that the parser does not know how to parse.  A good example of special
1084    case would be ARM's register displacement syntax:
1085
1086     [R0, #4]  ;; displacing R0 by 4
1087
1088    Since the parser assumes that a register displacement is of the form:
1089
1090     <number> <indirection_prefix> <register_name> <indirection_suffix>
1091
1092    it means that it will not be able to recognize and parse this odd syntax.
1093    Therefore, we should add a special case function that will handle this token.
1094
1095    This function should generate the proper expression form of the expression
1096    using GDB's internal expression mechanism (e.g., `write_exp_elt_opcode'
1097    and so on).  It should also return 1 if the parsing was successful, or zero
1098    if the token was not recognized as a special token (in this case, returning
1099    zero means that the special parser is deferring the parsing to the generic
1100    parser), and should advance the buffer pointer (p->arg). */
1101
1102 extern int gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch);
1103
1104 typedef int (gdbarch_stap_parse_special_token_ftype) (struct gdbarch *gdbarch, struct stap_parse_info *p);
1105 extern int gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p);
1106 extern void set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype *stap_parse_special_token);
1107
1108 /* True if the list of shared libraries is one and only for all
1109    processes, as opposed to a list of shared libraries per inferior.
1110    This usually means that all processes, although may or may not share
1111    an address space, will see the same set of symbols at the same
1112    addresses. */
1113
1114 extern int gdbarch_has_global_solist (struct gdbarch *gdbarch);
1115 extern void set_gdbarch_has_global_solist (struct gdbarch *gdbarch, int has_global_solist);
1116
1117 /* On some targets, even though each inferior has its own private
1118    address space, the debug interface takes care of making breakpoints
1119    visible to all address spaces automatically.  For such cases,
1120    this property should be set to true. */
1121
1122 extern int gdbarch_has_global_breakpoints (struct gdbarch *gdbarch);
1123 extern void set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch, int has_global_breakpoints);
1124
1125 /* True if inferiors share an address space (e.g., uClinux). */
1126
1127 typedef int (gdbarch_has_shared_address_space_ftype) (struct gdbarch *gdbarch);
1128 extern int gdbarch_has_shared_address_space (struct gdbarch *gdbarch);
1129 extern void set_gdbarch_has_shared_address_space (struct gdbarch *gdbarch, gdbarch_has_shared_address_space_ftype *has_shared_address_space);
1130
1131 /* True if a fast tracepoint can be set at an address. */
1132
1133 typedef int (gdbarch_fast_tracepoint_valid_at_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg);
1134 extern int gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg);
1135 extern void set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at);
1136
1137 /* Return the "auto" target charset. */
1138
1139 typedef const char * (gdbarch_auto_charset_ftype) (void);
1140 extern const char * gdbarch_auto_charset (struct gdbarch *gdbarch);
1141 extern void set_gdbarch_auto_charset (struct gdbarch *gdbarch, gdbarch_auto_charset_ftype *auto_charset);
1142
1143 /* Return the "auto" target wide charset. */
1144
1145 typedef const char * (gdbarch_auto_wide_charset_ftype) (void);
1146 extern const char * gdbarch_auto_wide_charset (struct gdbarch *gdbarch);
1147 extern void set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch, gdbarch_auto_wide_charset_ftype *auto_wide_charset);
1148
1149 /* If non-empty, this is a file extension that will be opened in place
1150    of the file extension reported by the shared library list.
1151
1152    This is most useful for toolchains that use a post-linker tool,
1153    where the names of the files run on the target differ in extension
1154    compared to the names of the files GDB should load for debug info. */
1155
1156 extern const char * gdbarch_solib_symbols_extension (struct gdbarch *gdbarch);
1157 extern void set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch, const char * solib_symbols_extension);
1158
1159 /* If true, the target OS has DOS-based file system semantics.  That
1160    is, absolute paths include a drive name, and the backslash is
1161    considered a directory separator. */
1162
1163 extern int gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch);
1164 extern void set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch, int has_dos_based_file_system);
1165
1166 /* Generate bytecodes to collect the return address in a frame.
1167    Since the bytecodes run on the target, possibly with GDB not even
1168    connected, the full unwinding machinery is not available, and
1169    typically this function will issue bytecodes for one or more likely
1170    places that the return address may be found. */
1171
1172 typedef void (gdbarch_gen_return_address_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope);
1173 extern void gdbarch_gen_return_address (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope);
1174 extern void set_gdbarch_gen_return_address (struct gdbarch *gdbarch, gdbarch_gen_return_address_ftype *gen_return_address);
1175
1176 /* Implement the "info proc" command. */
1177
1178 extern int gdbarch_info_proc_p (struct gdbarch *gdbarch);
1179
1180 typedef void (gdbarch_info_proc_ftype) (struct gdbarch *gdbarch, char *args, enum info_proc_what what);
1181 extern void gdbarch_info_proc (struct gdbarch *gdbarch, char *args, enum info_proc_what what);
1182 extern void set_gdbarch_info_proc (struct gdbarch *gdbarch, gdbarch_info_proc_ftype *info_proc);
1183
1184 /* Iterate over all objfiles in the order that makes the most sense
1185    for the architecture to make global symbol searches.
1186
1187    CB is a callback function where OBJFILE is the objfile to be searched,
1188    and CB_DATA a pointer to user-defined data (the same data that is passed
1189    when calling this gdbarch method).  The iteration stops if this function
1190    returns nonzero.
1191
1192    CB_DATA is a pointer to some user-defined data to be passed to
1193    the callback.
1194
1195    If not NULL, CURRENT_OBJFILE corresponds to the objfile being
1196    inspected when the symbol search was requested. */
1197
1198 typedef void (gdbarch_iterate_over_objfiles_in_search_order_ftype) (struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile);
1199 extern void gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile);
1200 extern void set_gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch, gdbarch_iterate_over_objfiles_in_search_order_ftype *iterate_over_objfiles_in_search_order);
1201
1202 /* Definition for an unknown syscall, used basically in error-cases.  */
1203 #define UNKNOWN_SYSCALL (-1)
1204
1205 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
1206
1207
1208 /* Mechanism for co-ordinating the selection of a specific
1209    architecture.
1210
1211    GDB targets (*-tdep.c) can register an interest in a specific
1212    architecture.  Other GDB components can register a need to maintain
1213    per-architecture data.
1214
1215    The mechanisms below ensures that there is only a loose connection
1216    between the set-architecture command and the various GDB
1217    components.  Each component can independently register their need
1218    to maintain architecture specific data with gdbarch.
1219
1220    Pragmatics:
1221
1222    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
1223    didn't scale.
1224
1225    The more traditional mega-struct containing architecture specific
1226    data for all the various GDB components was also considered.  Since
1227    GDB is built from a variable number of (fairly independent)
1228    components it was determined that the global aproach was not
1229    applicable.  */
1230
1231
1232 /* Register a new architectural family with GDB.
1233
1234    Register support for the specified ARCHITECTURE with GDB.  When
1235    gdbarch determines that the specified architecture has been
1236    selected, the corresponding INIT function is called.
1237
1238    --
1239
1240    The INIT function takes two parameters: INFO which contains the
1241    information available to gdbarch about the (possibly new)
1242    architecture; ARCHES which is a list of the previously created
1243    ``struct gdbarch'' for this architecture.
1244
1245    The INFO parameter is, as far as possible, be pre-initialized with
1246    information obtained from INFO.ABFD or the global defaults.
1247
1248    The ARCHES parameter is a linked list (sorted most recently used)
1249    of all the previously created architures for this architecture
1250    family.  The (possibly NULL) ARCHES->gdbarch can used to access
1251    values from the previously selected architecture for this
1252    architecture family.
1253
1254    The INIT function shall return any of: NULL - indicating that it
1255    doesn't recognize the selected architecture; an existing ``struct
1256    gdbarch'' from the ARCHES list - indicating that the new
1257    architecture is just a synonym for an earlier architecture (see
1258    gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
1259    - that describes the selected architecture (see gdbarch_alloc()).
1260
1261    The DUMP_TDEP function shall print out all target specific values.
1262    Care should be taken to ensure that the function works in both the
1263    multi-arch and non- multi-arch cases.  */
1264
1265 struct gdbarch_list
1266 {
1267   struct gdbarch *gdbarch;
1268   struct gdbarch_list *next;
1269 };
1270
1271 struct gdbarch_info
1272 {
1273   /* Use default: NULL (ZERO).  */
1274   const struct bfd_arch_info *bfd_arch_info;
1275
1276   /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
1277   int byte_order;
1278
1279   int byte_order_for_code;
1280
1281   /* Use default: NULL (ZERO).  */
1282   bfd *abfd;
1283
1284   /* Use default: NULL (ZERO).  */
1285   struct gdbarch_tdep_info *tdep_info;
1286
1287   /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
1288   enum gdb_osabi osabi;
1289
1290   /* Use default: NULL (ZERO).  */
1291   const struct target_desc *target_desc;
1292 };
1293
1294 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1295 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1296
1297 /* DEPRECATED - use gdbarch_register() */
1298 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1299
1300 extern void gdbarch_register (enum bfd_architecture architecture,
1301                               gdbarch_init_ftype *,
1302                               gdbarch_dump_tdep_ftype *);
1303
1304
1305 /* Return a freshly allocated, NULL terminated, array of the valid
1306    architecture names.  Since architectures are registered during the
1307    _initialize phase this function only returns useful information
1308    once initialization has been completed.  */
1309
1310 extern const char **gdbarch_printable_names (void);
1311
1312
1313 /* Helper function.  Search the list of ARCHES for a GDBARCH that
1314    matches the information provided by INFO.  */
1315
1316 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
1317
1318
1319 /* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
1320    basic initialization using values obtained from the INFO and TDEP
1321    parameters.  set_gdbarch_*() functions are called to complete the
1322    initialization of the object.  */
1323
1324 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1325
1326
1327 /* Helper function.  Free a partially-constructed ``struct gdbarch''.
1328    It is assumed that the caller freeds the ``struct
1329    gdbarch_tdep''.  */
1330
1331 extern void gdbarch_free (struct gdbarch *);
1332
1333
1334 /* Helper function.  Allocate memory from the ``struct gdbarch''
1335    obstack.  The memory is freed when the corresponding architecture
1336    is also freed.  */
1337
1338 extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size);
1339 #define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE)))
1340 #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE)))
1341
1342
1343 /* Helper function.  Force an update of the current architecture.
1344
1345    The actual architecture selected is determined by INFO, ``(gdb) set
1346    architecture'' et.al., the existing architecture and BFD's default
1347    architecture.  INFO should be initialized to zero and then selected
1348    fields should be updated.
1349
1350    Returns non-zero if the update succeeds.  */
1351
1352 extern int gdbarch_update_p (struct gdbarch_info info);
1353
1354
1355 /* Helper function.  Find an architecture matching info.
1356
1357    INFO should be initialized using gdbarch_info_init, relevant fields
1358    set, and then finished using gdbarch_info_fill.
1359
1360    Returns the corresponding architecture, or NULL if no matching
1361    architecture was found.  */
1362
1363 extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
1364
1365
1366 /* Helper function.  Set the global "target_gdbarch" to "gdbarch".
1367
1368    FIXME: kettenis/20031124: Of the functions that follow, only
1369    gdbarch_from_bfd is supposed to survive.  The others will
1370    dissappear since in the future GDB will (hopefully) be truly
1371    multi-arch.  However, for now we're still stuck with the concept of
1372    a single active architecture.  */
1373
1374 extern void deprecated_target_gdbarch_select_hack (struct gdbarch *gdbarch);
1375
1376
1377 /* Register per-architecture data-pointer.
1378
1379    Reserve space for a per-architecture data-pointer.  An identifier
1380    for the reserved data-pointer is returned.  That identifer should
1381    be saved in a local static variable.
1382
1383    Memory for the per-architecture data shall be allocated using
1384    gdbarch_obstack_zalloc.  That memory will be deleted when the
1385    corresponding architecture object is deleted.
1386
1387    When a previously created architecture is re-selected, the
1388    per-architecture data-pointer for that previous architecture is
1389    restored.  INIT() is not re-called.
1390
1391    Multiple registrarants for any architecture are allowed (and
1392    strongly encouraged).  */
1393
1394 struct gdbarch_data;
1395
1396 typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
1397 extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
1398 typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
1399 extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
1400 extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1401                                          struct gdbarch_data *data,
1402                                          void *pointer);
1403
1404 extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1405
1406
1407 /* Set the dynamic target-system-dependent parameters (architecture,
1408    byte-order, ...) using information found in the BFD.  */
1409
1410 extern void set_gdbarch_from_file (bfd *);
1411
1412
1413 /* Initialize the current architecture to the "first" one we find on
1414    our list.  */
1415
1416 extern void initialize_current_architecture (void);
1417
1418 /* gdbarch trace variable */
1419 extern int gdbarch_debug;
1420
1421 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1422
1423 #endif