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 /* Return true if the return value of function is stored in the first hidden
 461    parameter.  In theory, this feature should be language-dependent, specified
 462    by language and its ABI, such as C++.  Unfortunately, compiler may
 463    implement it to a target-dependent feature.  So that we need such hook here
 464    to be aware of this in GDB. */
 465
 466 typedef int (gdbarch_return_in_first_hidden_param_p_ftype) (struct gdbarch *gdbarch, struct type *type);
 467 extern int gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, struct type *type);
 468 extern void set_gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, gdbarch_return_in_first_hidden_param_p_ftype *return_in_first_hidden_param_p);
 469
 470 typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
 471 extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
 472 extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue);
 473
 474 extern int gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch);
 475
 476 typedef CORE_ADDR (gdbarch_skip_main_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
 477 extern CORE_ADDR gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
 478 extern void set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype *skip_main_prologue);
 479
 480 typedef int (gdbarch_inner_than_ftype) (CORE_ADDR lhs, CORE_ADDR rhs);
 481 extern int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs);
 482 extern void set_gdbarch_inner_than (struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than);
 483
 484 typedef const gdb_byte * (gdbarch_breakpoint_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
 485 extern const gdb_byte * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
 486 extern void set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc);
 487
 488 /* Return the adjusted address and kind to use for Z0/Z1 packets.
 489    KIND is usually the memory length of the breakpoint, but may have a
 490    different target-specific meaning. */
 491
 492 typedef void (gdbarch_remote_breakpoint_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr);
 493 extern void gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr);
 494 extern void set_gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_remote_breakpoint_from_pc_ftype *remote_breakpoint_from_pc);
 495
 496 extern int gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch);
 497
 498 typedef CORE_ADDR (gdbarch_adjust_breakpoint_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
 499 extern CORE_ADDR gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
 500 extern void set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address);
 501
 502 typedef int (gdbarch_memory_insert_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
 503 extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
 504 extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint);
 505
 506 typedef int (gdbarch_memory_remove_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
 507 extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
 508 extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint);
 509
 510 extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch);
 511 extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break);
 512
 513 /* A function can be addressed by either it's "pointer" (possibly a
 514    descriptor address) or "entry point" (first executable instruction).
 515    The method "convert_from_func_ptr_addr" converting the former to the
 516    latter.  gdbarch_deprecated_function_start_offset is being used to implement
 517    a simplified subset of that functionality - the function's address
 518    corresponds to the "function pointer" and the function's start
 519    corresponds to the "function entry point" - and hence is redundant. */
 520
 521 extern CORE_ADDR gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch);
 522 extern void set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_function_start_offset);
 523
 524 /* Return the remote protocol register number associated with this
 525    register.  Normally the identity mapping. */
 526
 527 typedef int (gdbarch_remote_register_number_ftype) (struct gdbarch *gdbarch, int regno);
 528 extern int gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno);
 529 extern void set_gdbarch_remote_register_number (struct gdbarch *gdbarch, gdbarch_remote_register_number_ftype *remote_register_number);
 530
 531 /* Fetch the target specific address used to represent a load module. */
 532
 533 extern int gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch);
 534
 535 typedef CORE_ADDR (gdbarch_fetch_tls_load_module_address_ftype) (struct objfile *objfile);
 536 extern CORE_ADDR gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile);
 537 extern void set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address);
 538
 539 extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
 540 extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
 541
 542 extern int gdbarch_unwind_pc_p (struct gdbarch *gdbarch);
 543
 544 typedef CORE_ADDR (gdbarch_unwind_pc_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
 545 extern CORE_ADDR gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame);
 546 extern void set_gdbarch_unwind_pc (struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype *unwind_pc);
 547
 548 extern int gdbarch_unwind_sp_p (struct gdbarch *gdbarch);
 549
 550 typedef CORE_ADDR (gdbarch_unwind_sp_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
 551 extern CORE_ADDR gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame);
 552 extern void set_gdbarch_unwind_sp (struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype *unwind_sp);
 553
 554 /* DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
 555    frame-base.  Enable frame-base before frame-unwind. */
 556
 557 extern int gdbarch_frame_num_args_p (struct gdbarch *gdbarch);
 558
 559 typedef int (gdbarch_frame_num_args_ftype) (struct frame_info *frame);
 560 extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame);
 561 extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args);
 562
 563 extern int gdbarch_frame_align_p (struct gdbarch *gdbarch);
 564
 565 typedef CORE_ADDR (gdbarch_frame_align_ftype) (struct gdbarch *gdbarch, CORE_ADDR address);
 566 extern CORE_ADDR gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address);
 567 extern void set_gdbarch_frame_align (struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align);
 568
 569 typedef int (gdbarch_stabs_argument_has_addr_ftype) (struct gdbarch *gdbarch, struct type *type);
 570 extern int gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type);
 571 extern void set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr);
 572
 573 extern int gdbarch_frame_red_zone_size (struct gdbarch *gdbarch);
 574 extern void set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch, int frame_red_zone_size);
 575
 576 typedef CORE_ADDR (gdbarch_convert_from_func_ptr_addr_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ);
 577 extern CORE_ADDR gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ);
 578 extern void set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr);
 579
 580 /* On some machines there are bits in addresses which are not really
 581    part of the address, but are used by the kernel, the hardware, etc.
 582    for special purposes.  gdbarch_addr_bits_remove takes out any such bits so
 583    we get a "real" address such as one would find in a symbol table.
 584    This is used only for addresses of instructions, and even then I'm
 585    not sure it's used in all contexts.  It exists to deal with there
 586    being a few stray bits in the PC which would mislead us, not as some
 587    sort of generic thing to handle alignment or segmentation (it's
 588    possible it should be in TARGET_READ_PC instead). */
 589
 590 typedef CORE_ADDR (gdbarch_addr_bits_remove_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
 591 extern CORE_ADDR gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr);
 592 extern void set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype *addr_bits_remove);
 593
 594 /* It is not at all clear why gdbarch_smash_text_address is not folded into
 595    gdbarch_addr_bits_remove. */
 596
 597 typedef CORE_ADDR (gdbarch_smash_text_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
 598 extern CORE_ADDR gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr);
 599 extern void set_gdbarch_smash_text_address (struct gdbarch *gdbarch, gdbarch_smash_text_address_ftype *smash_text_address);
 600
 601 /* FIXME/cagney/2001-01-18: This should be split in two.  A target method that
 602    indicates if the target needs software single step.  An ISA method to
 603    implement it.
 604
 605    FIXME/cagney/2001-01-18: This should be replaced with something that inserts
 606    breakpoints using the breakpoint system instead of blatting memory directly
 607    (as with rs6000).
 608
 609    FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the
 610    target can single step.  If not, then implement single step using breakpoints.
 611
 612    A return value of 1 means that the software_single_step breakpoints
 613    were inserted; 0 means they were not. */
 614
 615 extern int gdbarch_software_single_step_p (struct gdbarch *gdbarch);
 616
 617 typedef int (gdbarch_software_single_step_ftype) (struct frame_info *frame);
 618 extern int gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame);
 619 extern void set_gdbarch_software_single_step (struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step);
 620
 621 /* Return non-zero if the processor is executing a delay slot and a
 622    further single-step is needed before the instruction finishes. */
 623
 624 extern int gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch);
 625
 626 typedef int (gdbarch_single_step_through_delay_ftype) (struct gdbarch *gdbarch, struct frame_info *frame);
 627 extern int gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame);
 628 extern void set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch, gdbarch_single_step_through_delay_ftype *single_step_through_delay);
 629
 630 /* FIXME: cagney/2003-08-28: Need to find a better way of selecting the
 631    disassembler.  Perhaps objdump can handle it? */
 632
 633 typedef int (gdbarch_print_insn_ftype) (bfd_vma vma, struct disassemble_info *info);
 634 extern int gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info);
 635 extern void set_gdbarch_print_insn (struct gdbarch *gdbarch, gdbarch_print_insn_ftype *print_insn);
 636
 637 typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (struct frame_info *frame, CORE_ADDR pc);
 638 extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc);
 639 extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code);
 640
 641 /* If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER
 642    evaluates non-zero, this is the address where the debugger will place
 643    a step-resume breakpoint to get us past the dynamic linker. */
 644
 645 typedef CORE_ADDR (gdbarch_skip_solib_resolver_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc);
 646 extern CORE_ADDR gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc);
 647 extern void set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype *skip_solib_resolver);
 648
 649 /* Some systems also have trampoline code for returning from shared libs. */
 650
 651 typedef int (gdbarch_in_solib_return_trampoline_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name);
 652 extern int gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name);
 653 extern void set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline);
 654
 655 /* A target might have problems with watchpoints as soon as the stack
 656    frame of the current function has been destroyed.  This mostly happens
 657    as the first action in a funtion's epilogue.  in_function_epilogue_p()
 658    is defined to return a non-zero value if either the given addr is one
 659    instruction after the stack destroying instruction up to the trailing
 660    return instruction or if we can figure out that the stack frame has
 661    already been invalidated regardless of the value of addr.  Targets
 662    which don't suffer from that problem could just let this functionality
 663    untouched. */
 664
 665 typedef int (gdbarch_in_function_epilogue_p_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
 666 extern int gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr);
 667 extern void set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p);
 668
 669 typedef void (gdbarch_elf_make_msymbol_special_ftype) (asymbol *sym, struct minimal_symbol *msym);
 670 extern void gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym);
 671 extern void set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special);
 672
 673 typedef void (gdbarch_coff_make_msymbol_special_ftype) (int val, struct minimal_symbol *msym);
 674 extern void gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym);
 675 extern void set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special);
 676
 677 extern int gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch);
 678 extern void set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, int cannot_step_breakpoint);
 679
 680 extern int gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch);
 681 extern void set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, int have_nonsteppable_watchpoint);
 682
 683 extern int gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch);
 684
 685 typedef int (gdbarch_address_class_type_flags_ftype) (int byte_size, int dwarf2_addr_class);
 686 extern int gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class);
 687 extern void set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags);
 688
 689 extern int gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch);
 690
 691 typedef const char * (gdbarch_address_class_type_flags_to_name_ftype) (struct gdbarch *gdbarch, int type_flags);
 692 extern const char * gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags);
 693 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);
 694
 695 extern int gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch);
 696
 697 typedef int (gdbarch_address_class_name_to_type_flags_ftype) (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
 698 extern int gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
 699 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);
 700
 701 /* Is a register in a group */
 702
 703 typedef int (gdbarch_register_reggroup_p_ftype) (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
 704 extern int gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
 705 extern void set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p);
 706
 707 /* Fetch the pointer to the ith function argument. */
 708
 709 extern int gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch);
 710
 711 typedef CORE_ADDR (gdbarch_fetch_pointer_argument_ftype) (struct frame_info *frame, int argi, struct type *type);
 712 extern CORE_ADDR gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type);
 713 extern void set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument);
 714
 715 /* Return the appropriate register set for a core file section with
 716    name SECT_NAME and size SECT_SIZE. */
 717
 718 extern int gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch);
 719
 720 typedef const struct regset * (gdbarch_regset_from_core_section_ftype) (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size);
 721 extern const struct regset * gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size);
 722 extern void set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch, gdbarch_regset_from_core_section_ftype *regset_from_core_section);
 723
 724 /* Supported register notes in a core file. */
 725
 726 extern struct core_regset_section * gdbarch_core_regset_sections (struct gdbarch *gdbarch);
 727 extern void set_gdbarch_core_regset_sections (struct gdbarch *gdbarch, struct core_regset_section * core_regset_sections);
 728
 729 /* Create core file notes */
 730
 731 extern int gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch);
 732
 733 typedef char * (gdbarch_make_corefile_notes_ftype) (struct gdbarch *gdbarch, bfd *obfd, int *note_size);
 734 extern char * gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size);
 735 extern void set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch, gdbarch_make_corefile_notes_ftype *make_corefile_notes);
 736
 737 /* Find core file memory regions */
 738
 739 extern int gdbarch_find_memory_regions_p (struct gdbarch *gdbarch);
 740
 741 typedef int (gdbarch_find_memory_regions_ftype) (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data);
 742 extern int gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data);
 743 extern void set_gdbarch_find_memory_regions (struct gdbarch *gdbarch, gdbarch_find_memory_regions_ftype *find_memory_regions);
 744
 745 /* Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
 746    core file into buffer READBUF with length LEN. */
 747
 748 extern int gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch);
 749
 750 typedef LONGEST (gdbarch_core_xfer_shared_libraries_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len);
 751 extern LONGEST gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len);
 752 extern void set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries);
 753
 754 /* How the core target converts a PTID from a core file to a string. */
 755
 756 extern int gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch);
 757
 758 typedef char * (gdbarch_core_pid_to_str_ftype) (struct gdbarch *gdbarch, ptid_t ptid);
 759 extern char * gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid);
 760 extern void set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch, gdbarch_core_pid_to_str_ftype *core_pid_to_str);
 761
 762 /* BFD target to use when generating a core file. */
 763
 764 extern int gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch);
 765
 766 extern const char * gdbarch_gcore_bfd_target (struct gdbarch *gdbarch);
 767 extern void set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch, const char * gcore_bfd_target);
 768
 769 /* If the elements of C++ vtables are in-place function descriptors rather
 770    than normal function pointers (which may point to code or a descriptor),
 771    set this to one. */
 772
 773 extern int gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch);
 774 extern void set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch, int vtable_function_descriptors);
 775
 776 /* Set if the least significant bit of the delta is used instead of the least
 777    significant bit of the pfn for pointers to virtual member functions. */
 778
 779 extern int gdbarch_vbit_in_delta (struct gdbarch *gdbarch);
 780 extern void set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch, int vbit_in_delta);
 781
 782 /* Advance PC to next instruction in order to skip a permanent breakpoint. */
 783
 784 extern int gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch);
 785
 786 typedef void (gdbarch_skip_permanent_breakpoint_ftype) (struct regcache *regcache);
 787 extern void gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache);
 788 extern void set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint);
 789
 790 /* The maximum length of an instruction on this architecture in bytes. */
 791
 792 extern int gdbarch_max_insn_length_p (struct gdbarch *gdbarch);
 793
 794 extern ULONGEST gdbarch_max_insn_length (struct gdbarch *gdbarch);
 795 extern void set_gdbarch_max_insn_length (struct gdbarch *gdbarch, ULONGEST max_insn_length);
 796
 797 /* Copy the instruction at FROM to TO, and make any adjustments
 798    necessary to single-step it at that address.
 799
 800    REGS holds the state the thread's registers will have before
 801    executing the copied instruction; the PC in REGS will refer to FROM,
 802    not the copy at TO.  The caller should update it to point at TO later.
 803
 804    Return a pointer to data of the architecture's choice to be passed
 805    to gdbarch_displaced_step_fixup.  Or, return NULL to indicate that
 806    the instruction's effects have been completely simulated, with the
 807    resulting state written back to REGS.
 808
 809    For a general explanation of displaced stepping and how GDB uses it,
 810    see the comments in infrun.c.
 811
 812    The TO area is only guaranteed to have space for
 813    gdbarch_max_insn_length (arch) bytes, so this function must not
 814    write more bytes than that to that area.
 815
 816    If you do not provide this function, GDB assumes that the
 817    architecture does not support displaced stepping.
 818
 819    If your architecture doesn't need to adjust instructions before
 820    single-stepping them, consider using simple_displaced_step_copy_insn
 821    here. */
 822
 823 extern int gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch);
 824
 825 typedef struct displaced_step_closure * (gdbarch_displaced_step_copy_insn_ftype) (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
 826 extern struct displaced_step_closure * gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
 827 extern void set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn);
 828
 829 /* Return true if GDB should use hardware single-stepping to execute
 830    the displaced instruction identified by CLOSURE.  If false,
 831    GDB will simply restart execution at the displaced instruction
 832    location, and it is up to the target to ensure GDB will receive
 833    control again (e.g. by placing a software breakpoint instruction
 834    into the displaced instruction buffer).
 835
 836    The default implementation returns false on all targets that
 837    provide a gdbarch_software_single_step routine, and true otherwise. */
 838
 839 typedef int (gdbarch_displaced_step_hw_singlestep_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
 840 extern int gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
 841 extern void set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep);
 842
 843 /* Fix up the state resulting from successfully single-stepping a
 844    displaced instruction, to give the result we would have gotten from
 845    stepping the instruction in its original location.
 846
 847    REGS is the register state resulting from single-stepping the
 848    displaced instruction.
 849
 850    CLOSURE is the result from the matching call to
 851    gdbarch_displaced_step_copy_insn.
 852
 853    If you provide gdbarch_displaced_step_copy_insn.but not this
 854    function, then GDB assumes that no fixup is needed after
 855    single-stepping the instruction.
 856
 857    For a general explanation of displaced stepping and how GDB uses it,
 858    see the comments in infrun.c. */
 859
 860 extern int gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch);
 861
 862 typedef void (gdbarch_displaced_step_fixup_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
 863 extern void gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
 864 extern void set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype *displaced_step_fixup);
 865
 866 /* Free a closure returned by gdbarch_displaced_step_copy_insn.
 867
 868    If you provide gdbarch_displaced_step_copy_insn, you must provide
 869    this function as well.
 870
 871    If your architecture uses closures that don't need to be freed, then
 872    you can use simple_displaced_step_free_closure here.
 873
 874    For a general explanation of displaced stepping and how GDB uses it,
 875    see the comments in infrun.c. */
 876
 877 typedef void (gdbarch_displaced_step_free_closure_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
 878 extern void gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
 879 extern void set_gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, gdbarch_displaced_step_free_closure_ftype *displaced_step_free_closure);
 880
 881 /* Return the address of an appropriate place to put displaced
 882    instructions while we step over them.  There need only be one such
 883    place, since we're only stepping one thread over a breakpoint at a
 884    time.
 885
 886    For a general explanation of displaced stepping and how GDB uses it,
 887    see the comments in infrun.c. */
 888
 889 typedef CORE_ADDR (gdbarch_displaced_step_location_ftype) (struct gdbarch *gdbarch);
 890 extern CORE_ADDR gdbarch_displaced_step_location (struct gdbarch *gdbarch);
 891 extern void set_gdbarch_displaced_step_location (struct gdbarch *gdbarch, gdbarch_displaced_step_location_ftype *displaced_step_location);
 892
 893 /* Relocate an instruction to execute at a different address.  OLDLOC
 894    is the address in the inferior memory where the instruction to
 895    relocate is currently at.  On input, TO points to the destination
 896    where we want the instruction to be copied (and possibly adjusted)
 897    to.  On output, it points to one past the end of the resulting
 898    instruction(s).  The effect of executing the instruction at TO shall
 899    be the same as if executing it at FROM.  For example, call
 900    instructions that implicitly push the return address on the stack
 901    should be adjusted to return to the instruction after OLDLOC;
 902    relative branches, and other PC-relative instructions need the
 903    offset adjusted; etc. */
 904
 905 extern int gdbarch_relocate_instruction_p (struct gdbarch *gdbarch);
 906
 907 typedef void (gdbarch_relocate_instruction_ftype) (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from);
 908 extern void gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from);
 909 extern void set_gdbarch_relocate_instruction (struct gdbarch *gdbarch, gdbarch_relocate_instruction_ftype *relocate_instruction);
 910
 911 /* Refresh overlay mapped state for section OSECT. */
 912
 913 extern int gdbarch_overlay_update_p (struct gdbarch *gdbarch);
 914
 915 typedef void (gdbarch_overlay_update_ftype) (struct obj_section *osect);
 916 extern void gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect);
 917 extern void set_gdbarch_overlay_update (struct gdbarch *gdbarch, gdbarch_overlay_update_ftype *overlay_update);
 918
 919 extern int gdbarch_core_read_description_p (struct gdbarch *gdbarch);
 920
 921 typedef const struct target_desc * (gdbarch_core_read_description_ftype) (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
 922 extern const struct target_desc * gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
 923 extern void set_gdbarch_core_read_description (struct gdbarch *gdbarch, gdbarch_core_read_description_ftype *core_read_description);
 924
 925 /* Handle special encoding of static variables in stabs debug info. */
 926
 927 extern int gdbarch_static_transform_name_p (struct gdbarch *gdbarch);
 928
 929 typedef const char * (gdbarch_static_transform_name_ftype) (const char *name);
 930 extern const char * gdbarch_static_transform_name (struct gdbarch *gdbarch, const char *name);
 931 extern void set_gdbarch_static_transform_name (struct gdbarch *gdbarch, gdbarch_static_transform_name_ftype *static_transform_name);
 932
 933 /* Set if the address in N_SO or N_FUN stabs may be zero. */
 934
 935 extern int gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch);
 936 extern void set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch, int sofun_address_maybe_missing);
 937
 938 /* Parse the instruction at ADDR storing in the record execution log
 939    the registers REGCACHE and memory ranges that will be affected when
 940    the instruction executes, along with their current values.
 941    Return -1 if something goes wrong, 0 otherwise. */
 942
 943 extern int gdbarch_process_record_p (struct gdbarch *gdbarch);
 944
 945 typedef int (gdbarch_process_record_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
 946 extern int gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
 947 extern void set_gdbarch_process_record (struct gdbarch *gdbarch, gdbarch_process_record_ftype *process_record);
 948
 949 /* Save process state after a signal.
 950    Return -1 if something goes wrong, 0 otherwise. */
 951
 952 extern int gdbarch_process_record_signal_p (struct gdbarch *gdbarch);
 953
 954 typedef int (gdbarch_process_record_signal_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal);
 955 extern int gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal);
 956 extern void set_gdbarch_process_record_signal (struct gdbarch *gdbarch, gdbarch_process_record_signal_ftype *process_record_signal);
 957
 958 /* Signal translation: translate inferior's signal (target's) number
 959    into GDB's representation.  The implementation of this method must
 960    be host independent.  IOW, don't rely on symbols of the NAT_FILE
 961    header (the nm-*.h files), the host <signal.h> header, or similar
 962    headers.  This is mainly used when cross-debugging core files ---
 963    "Live" targets hide the translation behind the target interface
 964    (target_wait, target_resume, etc.). */
 965
 966 extern int gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch);
 967
 968 typedef enum gdb_signal (gdbarch_gdb_signal_from_target_ftype) (struct gdbarch *gdbarch, int signo);
 969 extern enum gdb_signal gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, int signo);
 970 extern void set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target);
 971
 972 /* Extra signal info inspection.
 973
 974    Return a type suitable to inspect extra signal information. */
 975
 976 extern int gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch);
 977
 978 typedef struct type * (gdbarch_get_siginfo_type_ftype) (struct gdbarch *gdbarch);
 979 extern struct type * gdbarch_get_siginfo_type (struct gdbarch *gdbarch);
 980 extern void set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch, gdbarch_get_siginfo_type_ftype *get_siginfo_type);
 981
 982 /* Record architecture-specific information from the symbol table. */
 983
 984 extern int gdbarch_record_special_symbol_p (struct gdbarch *gdbarch);
 985
 986 typedef void (gdbarch_record_special_symbol_ftype) (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym);
 987 extern void gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym);
 988 extern void set_gdbarch_record_special_symbol (struct gdbarch *gdbarch, gdbarch_record_special_symbol_ftype *record_special_symbol);
 989
 990 /* Function for the 'catch syscall' feature.
 991    Get architecture-specific system calls information from registers. */
 992
 993 extern int gdbarch_get_syscall_number_p (struct gdbarch *gdbarch);
 994
 995 typedef LONGEST (gdbarch_get_syscall_number_ftype) (struct gdbarch *gdbarch, ptid_t ptid);
 996 extern LONGEST gdbarch_get_syscall_number (struct gdbarch *gdbarch, ptid_t ptid);
 997 extern void set_gdbarch_get_syscall_number (struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype *get_syscall_number);
 998
 999 /* SystemTap related fields and functions.
1000    Prefix used to mark an integer constant on the architecture's assembly
1001    For example, on x86 integer constants are written as:
1002
1003     $10 ;; integer constant 10
1004
1005    in this case, this prefix would be the character `$'. */
1006
1007 extern const char * gdbarch_stap_integer_prefix (struct gdbarch *gdbarch);
1008 extern void set_gdbarch_stap_integer_prefix (struct gdbarch *gdbarch, const char * stap_integer_prefix);
1009
1010 /* Suffix used to mark an integer constant on the architecture's assembly. */
1011
1012 extern const char * gdbarch_stap_integer_suffix (struct gdbarch *gdbarch);
1013 extern void set_gdbarch_stap_integer_suffix (struct gdbarch *gdbarch, const char * stap_integer_suffix);
1014
1015 /* Prefix used to mark a register name on the architecture's assembly.
1016    For example, on x86 the register name is written as:
1017
1018     %eax ;; register eax
1019
1020    in this case, this prefix would be the character `%'. */
1021
1022 extern const char * gdbarch_stap_register_prefix (struct gdbarch *gdbarch);
1023 extern void set_gdbarch_stap_register_prefix (struct gdbarch *gdbarch, const char * stap_register_prefix);
1024
1025 /* Suffix used to mark a register name on the architecture's assembly */
1026
1027 extern const char * gdbarch_stap_register_suffix (struct gdbarch *gdbarch);
1028 extern void set_gdbarch_stap_register_suffix (struct gdbarch *gdbarch, const char * stap_register_suffix);
1029
1030 /* Prefix used to mark a register indirection on the architecture's assembly.
1031    For example, on x86 the register indirection is written as:
1032
1033     (%eax) ;; indirecting eax
1034
1035    in this case, this prefix would be the charater `('.
1036
1037    Please note that we use the indirection prefix also for register
1038    displacement, e.g., `4(%eax)' on x86. */
1039
1040 extern const char * gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch);
1041 extern void set_gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch, const char * stap_register_indirection_prefix);
1042
1043 /* Suffix used to mark a register indirection on the architecture's assembly.
1044    For example, on x86 the register indirection is written as:
1045
1046     (%eax) ;; indirecting eax
1047
1048    in this case, this prefix would be the charater `)'.
1049
1050    Please note that we use the indirection suffix also for register
1051    displacement, e.g., `4(%eax)' on x86. */
1052
1053 extern const char * gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch);
1054 extern void set_gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch, const char * stap_register_indirection_suffix);
1055
1056 /* Prefix used to name a register using GDB's nomenclature.
1057
1058    For example, on PPC a register is represented by a number in the assembly
1059    language (e.g., `10' is the 10th general-purpose register).  However,
1060    inside GDB this same register has an `r' appended to its name, so the 10th
1061    register would be represented as `r10' internally. */
1062
1063 extern const char * gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch);
1064 extern void set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch, const char * stap_gdb_register_prefix);
1065
1066 /* Suffix used to name a register using GDB's nomenclature. */
1067
1068 extern const char * gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch);
1069 extern void set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch, const char * stap_gdb_register_suffix);
1070
1071 /* Check if S is a single operand.
1072
1073    Single operands can be:
1074     - Literal integers, e.g. `$10' on x86
1075     - Register access, e.g. `%eax' on x86
1076     - Register indirection, e.g. `(%eax)' on x86
1077     - Register displacement, e.g. `4(%eax)' on x86
1078
1079    This function should check for these patterns on the string
1080    and return 1 if some were found, or zero otherwise.  Please try to match
1081    as much info as you can from the string, i.e., if you have to match
1082    something like `(%', do not match just the `('. */
1083
1084 extern int gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch);
1085
1086 typedef int (gdbarch_stap_is_single_operand_ftype) (struct gdbarch *gdbarch, const char *s);
1087 extern int gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s);
1088 extern void set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand);
1089
1090 /* Function used to handle a "special case" in the parser.
1091
1092    A "special case" is considered to be an unknown token, i.e., a token
1093    that the parser does not know how to parse.  A good example of special
1094    case would be ARM's register displacement syntax:
1095
1096     [R0, #4]  ;; displacing R0 by 4
1097
1098    Since the parser assumes that a register displacement is of the form:
1099
1100     <number> <indirection_prefix> <register_name> <indirection_suffix>
1101
1102    it means that it will not be able to recognize and parse this odd syntax.
1103    Therefore, we should add a special case function that will handle this token.
1104
1105    This function should generate the proper expression form of the expression
1106    using GDB's internal expression mechanism (e.g., `write_exp_elt_opcode'
1107    and so on).  It should also return 1 if the parsing was successful, or zero
1108    if the token was not recognized as a special token (in this case, returning
1109    zero means that the special parser is deferring the parsing to the generic
1110    parser), and should advance the buffer pointer (p->arg). */
1111
1112 extern int gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch);
1113
1114 typedef int (gdbarch_stap_parse_special_token_ftype) (struct gdbarch *gdbarch, struct stap_parse_info *p);
1115 extern int gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p);
1116 extern void set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype *stap_parse_special_token);
1117
1118 /* True if the list of shared libraries is one and only for all
1119    processes, as opposed to a list of shared libraries per inferior.
1120    This usually means that all processes, although may or may not share
1121    an address space, will see the same set of symbols at the same
1122    addresses. */
1123
1124 extern int gdbarch_has_global_solist (struct gdbarch *gdbarch);
1125 extern void set_gdbarch_has_global_solist (struct gdbarch *gdbarch, int has_global_solist);
1126
1127 /* On some targets, even though each inferior has its own private
1128    address space, the debug interface takes care of making breakpoints
1129    visible to all address spaces automatically.  For such cases,
1130    this property should be set to true. */
1131
1132 extern int gdbarch_has_global_breakpoints (struct gdbarch *gdbarch);
1133 extern void set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch, int has_global_breakpoints);
1134
1135 /* True if inferiors share an address space (e.g., uClinux). */
1136
1137 typedef int (gdbarch_has_shared_address_space_ftype) (struct gdbarch *gdbarch);
1138 extern int gdbarch_has_shared_address_space (struct gdbarch *gdbarch);
1139 extern void set_gdbarch_has_shared_address_space (struct gdbarch *gdbarch, gdbarch_has_shared_address_space_ftype *has_shared_address_space);
1140
1141 /* True if a fast tracepoint can be set at an address. */
1142
1143 typedef int (gdbarch_fast_tracepoint_valid_at_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg);
1144 extern int gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg);
1145 extern void set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at);
1146
1147 /* Return the "auto" target charset. */
1148
1149 typedef const char * (gdbarch_auto_charset_ftype) (void);
1150 extern const char * gdbarch_auto_charset (struct gdbarch *gdbarch);
1151 extern void set_gdbarch_auto_charset (struct gdbarch *gdbarch, gdbarch_auto_charset_ftype *auto_charset);
1152
1153 /* Return the "auto" target wide charset. */
1154
1155 typedef const char * (gdbarch_auto_wide_charset_ftype) (void);
1156 extern const char * gdbarch_auto_wide_charset (struct gdbarch *gdbarch);
1157 extern void set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch, gdbarch_auto_wide_charset_ftype *auto_wide_charset);
1158
1159 /* If non-empty, this is a file extension that will be opened in place
1160    of the file extension reported by the shared library list.
1161
1162    This is most useful for toolchains that use a post-linker tool,
1163    where the names of the files run on the target differ in extension
1164    compared to the names of the files GDB should load for debug info. */
1165
1166 extern const char * gdbarch_solib_symbols_extension (struct gdbarch *gdbarch);
1167 extern void set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch, const char * solib_symbols_extension);
1168
1169 /* If true, the target OS has DOS-based file system semantics.  That
1170    is, absolute paths include a drive name, and the backslash is
1171    considered a directory separator. */
1172
1173 extern int gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch);
1174 extern void set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch, int has_dos_based_file_system);
1175
1176 /* Generate bytecodes to collect the return address in a frame.
1177    Since the bytecodes run on the target, possibly with GDB not even
1178    connected, the full unwinding machinery is not available, and
1179    typically this function will issue bytecodes for one or more likely
1180    places that the return address may be found. */
1181
1182 typedef void (gdbarch_gen_return_address_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope);
1183 extern void gdbarch_gen_return_address (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope);
1184 extern void set_gdbarch_gen_return_address (struct gdbarch *gdbarch, gdbarch_gen_return_address_ftype *gen_return_address);
1185
1186 /* Implement the "info proc" command. */
1187
1188 extern int gdbarch_info_proc_p (struct gdbarch *gdbarch);
1189
1190 typedef void (gdbarch_info_proc_ftype) (struct gdbarch *gdbarch, char *args, enum info_proc_what what);
1191 extern void gdbarch_info_proc (struct gdbarch *gdbarch, char *args, enum info_proc_what what);
1192 extern void set_gdbarch_info_proc (struct gdbarch *gdbarch, gdbarch_info_proc_ftype *info_proc);
1193
1194 /* Iterate over all objfiles in the order that makes the most sense
1195    for the architecture to make global symbol searches.
1196
1197    CB is a callback function where OBJFILE is the objfile to be searched,
1198    and CB_DATA a pointer to user-defined data (the same data that is passed
1199    when calling this gdbarch method).  The iteration stops if this function
1200    returns nonzero.
1201
1202    CB_DATA is a pointer to some user-defined data to be passed to
1203    the callback.
1204
1205    If not NULL, CURRENT_OBJFILE corresponds to the objfile being
1206    inspected when the symbol search was requested. */
1207
1208 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);
1209 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);
1210 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);
1211
1212 /* Definition for an unknown syscall, used basically in error-cases.  */
1213 #define UNKNOWN_SYSCALL (-1)
1214
1215 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
1216
1217
1218 /* Mechanism for co-ordinating the selection of a specific
1219    architecture.
1220
1221    GDB targets (*-tdep.c) can register an interest in a specific
1222    architecture.  Other GDB components can register a need to maintain
1223    per-architecture data.
1224
1225    The mechanisms below ensures that there is only a loose connection
1226    between the set-architecture command and the various GDB
1227    components.  Each component can independently register their need
1228    to maintain architecture specific data with gdbarch.
1229
1230    Pragmatics:
1231
1232    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
1233    didn't scale.
1234
1235    The more traditional mega-struct containing architecture specific
1236    data for all the various GDB components was also considered.  Since
1237    GDB is built from a variable number of (fairly independent)
1238    components it was determined that the global aproach was not
1239    applicable.  */
1240
1241
1242 /* Register a new architectural family with GDB.
1243
1244    Register support for the specified ARCHITECTURE with GDB.  When
1245    gdbarch determines that the specified architecture has been
1246    selected, the corresponding INIT function is called.
1247
1248    --
1249
1250    The INIT function takes two parameters: INFO which contains the
1251    information available to gdbarch about the (possibly new)
1252    architecture; ARCHES which is a list of the previously created
1253    ``struct gdbarch'' for this architecture.
1254
1255    The INFO parameter is, as far as possible, be pre-initialized with
1256    information obtained from INFO.ABFD or the global defaults.
1257
1258    The ARCHES parameter is a linked list (sorted most recently used)
1259    of all the previously created architures for this architecture
1260    family.  The (possibly NULL) ARCHES->gdbarch can used to access
1261    values from the previously selected architecture for this
1262    architecture family.
1263
1264    The INIT function shall return any of: NULL - indicating that it
1265    doesn't recognize the selected architecture; an existing ``struct
1266    gdbarch'' from the ARCHES list - indicating that the new
1267    architecture is just a synonym for an earlier architecture (see
1268    gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
1269    - that describes the selected architecture (see gdbarch_alloc()).
1270
1271    The DUMP_TDEP function shall print out all target specific values.
1272    Care should be taken to ensure that the function works in both the
1273    multi-arch and non- multi-arch cases.  */
1274
1275 struct gdbarch_list
1276 {
1277   struct gdbarch *gdbarch;
1278   struct gdbarch_list *next;
1279 };
1280
1281 struct gdbarch_info
1282 {
1283   /* Use default: NULL (ZERO).  */
1284   const struct bfd_arch_info *bfd_arch_info;
1285
1286   /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
1287   int byte_order;
1288
1289   int byte_order_for_code;
1290
1291   /* Use default: NULL (ZERO).  */
1292   bfd *abfd;
1293
1294   /* Use default: NULL (ZERO).  */
1295   struct gdbarch_tdep_info *tdep_info;
1296
1297   /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
1298   enum gdb_osabi osabi;
1299
1300   /* Use default: NULL (ZERO).  */
1301   const struct target_desc *target_desc;
1302 };
1303
1304 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1305 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1306
1307 /* DEPRECATED - use gdbarch_register() */
1308 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1309
1310 extern void gdbarch_register (enum bfd_architecture architecture,
1311                               gdbarch_init_ftype *,
1312                               gdbarch_dump_tdep_ftype *);
1313
1314
1315 /* Return a freshly allocated, NULL terminated, array of the valid
1316    architecture names.  Since architectures are registered during the
1317    _initialize phase this function only returns useful information
1318    once initialization has been completed.  */
1319
1320 extern const char **gdbarch_printable_names (void);
1321
1322
1323 /* Helper function.  Search the list of ARCHES for a GDBARCH that
1324    matches the information provided by INFO.  */
1325
1326 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
1327
1328
1329 /* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
1330    basic initialization using values obtained from the INFO and TDEP
1331    parameters.  set_gdbarch_*() functions are called to complete the
1332    initialization of the object.  */
1333
1334 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1335
1336
1337 /* Helper function.  Free a partially-constructed ``struct gdbarch''.
1338    It is assumed that the caller freeds the ``struct
1339    gdbarch_tdep''.  */
1340
1341 extern void gdbarch_free (struct gdbarch *);
1342
1343
1344 /* Helper function.  Allocate memory from the ``struct gdbarch''
1345    obstack.  The memory is freed when the corresponding architecture
1346    is also freed.  */
1347
1348 extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size);
1349 #define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE)))
1350 #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE)))
1351
1352
1353 /* Helper function.  Force an update of the current architecture.
1354
1355    The actual architecture selected is determined by INFO, ``(gdb) set
1356    architecture'' et.al., the existing architecture and BFD's default
1357    architecture.  INFO should be initialized to zero and then selected
1358    fields should be updated.
1359
1360    Returns non-zero if the update succeeds.  */
1361
1362 extern int gdbarch_update_p (struct gdbarch_info info);
1363
1364
1365 /* Helper function.  Find an architecture matching info.
1366
1367    INFO should be initialized using gdbarch_info_init, relevant fields
1368    set, and then finished using gdbarch_info_fill.
1369
1370    Returns the corresponding architecture, or NULL if no matching
1371    architecture was found.  */
1372
1373 extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
1374
1375
1376 /* Helper function.  Set the global "target_gdbarch" to "gdbarch".
1377
1378    FIXME: kettenis/20031124: Of the functions that follow, only
1379    gdbarch_from_bfd is supposed to survive.  The others will
1380    dissappear since in the future GDB will (hopefully) be truly
1381    multi-arch.  However, for now we're still stuck with the concept of
1382    a single active architecture.  */
1383
1384 extern void deprecated_target_gdbarch_select_hack (struct gdbarch *gdbarch);
1385
1386
1387 /* Register per-architecture data-pointer.
1388
1389    Reserve space for a per-architecture data-pointer.  An identifier
1390    for the reserved data-pointer is returned.  That identifer should
1391    be saved in a local static variable.
1392
1393    Memory for the per-architecture data shall be allocated using
1394    gdbarch_obstack_zalloc.  That memory will be deleted when the
1395    corresponding architecture object is deleted.
1396
1397    When a previously created architecture is re-selected, the
1398    per-architecture data-pointer for that previous architecture is
1399    restored.  INIT() is not re-called.
1400
1401    Multiple registrarants for any architecture are allowed (and
1402    strongly encouraged).  */
1403
1404 struct gdbarch_data;
1405
1406 typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
1407 extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
1408 typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
1409 extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
1410 extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1411                                          struct gdbarch_data *data,
1412                                          void *pointer);
1413
1414 extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1415
1416
1417 /* Set the dynamic target-system-dependent parameters (architecture,
1418    byte-order, ...) using information found in the BFD.  */
1419
1420 extern void set_gdbarch_from_file (bfd *);
1421
1422
1423 /* Initialize the current architecture to the "first" one we find on
1424    our list.  */
1425
1426 extern void initialize_current_architecture (void);
1427
1428 /* gdbarch trace variable */
1429 extern int gdbarch_debug;
1430
1431 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1432
1433 #endif