1/* *INDENT-OFF* */ /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */ 2/* vi:set ro: */ 3 4/* Dynamic architecture support for GDB, the GNU debugger. 5 6 Copyright (C) 1998-2020 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#ifndef GDBARCH_H 26#define GDBARCH_H 27 28#include <vector> 29#include "frame.h" 30#include "dis-asm.h" 31#include "gdb_obstack.h" 32#include "infrun.h" 33#include "osabi.h" 34 35struct floatformat; 36struct ui_file; 37struct value; 38struct objfile; 39struct obj_section; 40struct minimal_symbol; 41struct regcache; 42struct reggroup; 43struct regset; 44struct disassemble_info; 45struct target_ops; 46struct obstack; 47struct bp_target_info; 48struct target_desc; 49struct symbol; 50struct syscall; 51struct agent_expr; 52struct axs_value; 53struct stap_parse_info; 54struct expr_builder; 55struct ravenscar_arch_ops; 56struct mem_range; 57struct syscalls_info; 58struct thread_info; 59struct ui_out; 60 61#include "regcache.h" 62 63/* The architecture associated with the inferior through the 64 connection to the target. 65 66 The architecture vector provides some information that is really a 67 property of the inferior, accessed through a particular target: 68 ptrace operations; the layout of certain RSP packets; the solib_ops 69 vector; etc. To differentiate architecture accesses to 70 per-inferior/target properties from 71 per-thread/per-frame/per-objfile properties, accesses to 72 per-inferior/target properties should be made through this 73 gdbarch. */ 74 75/* This is a convenience wrapper for 'current_inferior ()->gdbarch'. */ 76extern struct gdbarch *target_gdbarch (void); 77 78/* Callback type for the 'iterate_over_objfiles_in_search_order' 79 gdbarch method. */ 80 81typedef int (iterate_over_objfiles_in_search_order_cb_ftype) 82 (struct objfile *objfile, void *cb_data); 83 84/* Callback type for regset section iterators. The callback usually 85 invokes the REGSET's supply or collect method, to which it must 86 pass a buffer - for collects this buffer will need to be created using 87 COLLECT_SIZE, for supply the existing buffer being read from should 88 be at least SUPPLY_SIZE. SECT_NAME is a BFD section name, and HUMAN_NAME 89 is used for diagnostic messages. CB_DATA should have been passed 90 unchanged through the iterator. */ 91 92typedef void (iterate_over_regset_sections_cb) 93 (const char *sect_name, int supply_size, int collect_size, 94 const struct regset *regset, const char *human_name, void *cb_data); 95 96/* For a function call, does the function return a value using a 97 normal value return or a structure return - passing a hidden 98 argument pointing to storage. For the latter, there are two 99 cases: language-mandated structure return and target ABI 100 structure return. */ 101 102enum function_call_return_method 103{ 104 /* Standard value return. */ 105 return_method_normal = 0, 106 107 /* Language ABI structure return. This is handled 108 by passing the return location as the first parameter to 109 the function, even preceding "this". */ 110 return_method_hidden_param, 111 112 /* Target ABI struct return. This is target-specific; for instance, 113 on ia64 the first argument is passed in out0 but the hidden 114 structure return pointer would normally be passed in r8. */ 115 return_method_struct, 116}; 117 118 119 120/* The following are pre-initialized by GDBARCH. */ 121 122extern const struct bfd_arch_info * gdbarch_bfd_arch_info (struct gdbarch *gdbarch); 123/* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */ 124 125extern enum bfd_endian gdbarch_byte_order (struct gdbarch *gdbarch); 126/* set_gdbarch_byte_order() - not applicable - pre-initialized. */ 127 128extern enum bfd_endian gdbarch_byte_order_for_code (struct gdbarch *gdbarch); 129/* set_gdbarch_byte_order_for_code() - not applicable - pre-initialized. */ 130 131extern enum gdb_osabi gdbarch_osabi (struct gdbarch *gdbarch); 132/* set_gdbarch_osabi() - not applicable - pre-initialized. */ 133 134extern const struct target_desc * gdbarch_target_desc (struct gdbarch *gdbarch); 135/* set_gdbarch_target_desc() - not applicable - pre-initialized. */ 136 137 138/* The following are initialized by the target dependent code. */ 139 140/* Number of bits in a short or unsigned short for the target machine. */ 141 142extern int gdbarch_short_bit (struct gdbarch *gdbarch); 143extern void set_gdbarch_short_bit (struct gdbarch *gdbarch, int short_bit); 144 145/* Number of bits in an int or unsigned int for the target machine. */ 146 147extern int gdbarch_int_bit (struct gdbarch *gdbarch); 148extern void set_gdbarch_int_bit (struct gdbarch *gdbarch, int int_bit); 149 150/* Number of bits in a long or unsigned long for the target machine. */ 151 152extern int gdbarch_long_bit (struct gdbarch *gdbarch); 153extern void set_gdbarch_long_bit (struct gdbarch *gdbarch, int long_bit); 154 155/* Number of bits in a long long or unsigned long long for the target 156 machine. */ 157 158extern int gdbarch_long_long_bit (struct gdbarch *gdbarch); 159extern void set_gdbarch_long_long_bit (struct gdbarch *gdbarch, int long_long_bit); 160 161/* The ABI default bit-size and format for "bfloat16", "half", "float", "double", and 162 "long double". These bit/format pairs should eventually be combined 163 into a single object. For the moment, just initialize them as a pair. 164 Each format describes both the big and little endian layouts (if 165 useful). */ 166 167extern int gdbarch_bfloat16_bit (struct gdbarch *gdbarch); 168extern void set_gdbarch_bfloat16_bit (struct gdbarch *gdbarch, int bfloat16_bit); 169 170extern const struct floatformat ** gdbarch_bfloat16_format (struct gdbarch *gdbarch); 171extern void set_gdbarch_bfloat16_format (struct gdbarch *gdbarch, const struct floatformat ** bfloat16_format); 172 173extern int gdbarch_half_bit (struct gdbarch *gdbarch); 174extern void set_gdbarch_half_bit (struct gdbarch *gdbarch, int half_bit); 175 176extern const struct floatformat ** gdbarch_half_format (struct gdbarch *gdbarch); 177extern void set_gdbarch_half_format (struct gdbarch *gdbarch, const struct floatformat ** half_format); 178 179extern int gdbarch_float_bit (struct gdbarch *gdbarch); 180extern void set_gdbarch_float_bit (struct gdbarch *gdbarch, int float_bit); 181 182extern const struct floatformat ** gdbarch_float_format (struct gdbarch *gdbarch); 183extern void set_gdbarch_float_format (struct gdbarch *gdbarch, const struct floatformat ** float_format); 184 185extern int gdbarch_double_bit (struct gdbarch *gdbarch); 186extern void set_gdbarch_double_bit (struct gdbarch *gdbarch, int double_bit); 187 188extern const struct floatformat ** gdbarch_double_format (struct gdbarch *gdbarch); 189extern void set_gdbarch_double_format (struct gdbarch *gdbarch, const struct floatformat ** double_format); 190 191extern int gdbarch_long_double_bit (struct gdbarch *gdbarch); 192extern void set_gdbarch_long_double_bit (struct gdbarch *gdbarch, int long_double_bit); 193 194extern const struct floatformat ** gdbarch_long_double_format (struct gdbarch *gdbarch); 195extern void set_gdbarch_long_double_format (struct gdbarch *gdbarch, const struct floatformat ** long_double_format); 196 197/* The ABI default bit-size for "wchar_t". wchar_t is a built-in type 198 starting with C++11. */ 199 200extern int gdbarch_wchar_bit (struct gdbarch *gdbarch); 201extern void set_gdbarch_wchar_bit (struct gdbarch *gdbarch, int wchar_bit); 202 203/* One if `wchar_t' is signed, zero if unsigned. */ 204 205extern int gdbarch_wchar_signed (struct gdbarch *gdbarch); 206extern void set_gdbarch_wchar_signed (struct gdbarch *gdbarch, int wchar_signed); 207 208/* Returns the floating-point format to be used for values of length LENGTH. 209 NAME, if non-NULL, is the type name, which may be used to distinguish 210 different target formats of the same length. */ 211 212typedef const struct floatformat ** (gdbarch_floatformat_for_type_ftype) (struct gdbarch *gdbarch, const char *name, int length); 213extern const struct floatformat ** gdbarch_floatformat_for_type (struct gdbarch *gdbarch, const char *name, int length); 214extern void set_gdbarch_floatformat_for_type (struct gdbarch *gdbarch, gdbarch_floatformat_for_type_ftype *floatformat_for_type); 215 216/* For most targets, a pointer on the target and its representation as an 217 address in GDB have the same size and "look the same". For such a 218 target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit 219 / addr_bit will be set from it. 220 221 If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably 222 also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and 223 gdbarch_address_to_pointer as well. 224 225 ptr_bit is the size of a pointer on the target */ 226 227extern int gdbarch_ptr_bit (struct gdbarch *gdbarch); 228extern void set_gdbarch_ptr_bit (struct gdbarch *gdbarch, int ptr_bit); 229 230/* addr_bit is the size of a target address as represented in gdb */ 231 232extern int gdbarch_addr_bit (struct gdbarch *gdbarch); 233extern void set_gdbarch_addr_bit (struct gdbarch *gdbarch, int addr_bit); 234 235/* dwarf2_addr_size is the target address size as used in the Dwarf debug 236 info. For .debug_frame FDEs, this is supposed to be the target address 237 size from the associated CU header, and which is equivalent to the 238 DWARF2_ADDR_SIZE as defined by the target specific GCC back-end. 239 Unfortunately there is no good way to determine this value. Therefore 240 dwarf2_addr_size simply defaults to the target pointer size. 241 242 dwarf2_addr_size is not used for .eh_frame FDEs, which are generally 243 defined using the target's pointer size so far. 244 245 Note that dwarf2_addr_size only needs to be redefined by a target if the 246 GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size, 247 and if Dwarf versions < 4 need to be supported. */ 248 249extern int gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch); 250extern void set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch, int dwarf2_addr_size); 251 252/* One if `char' acts like `signed char', zero if `unsigned char'. */ 253 254extern int gdbarch_char_signed (struct gdbarch *gdbarch); 255extern void set_gdbarch_char_signed (struct gdbarch *gdbarch, int char_signed); 256 257extern int gdbarch_read_pc_p (struct gdbarch *gdbarch); 258 259typedef CORE_ADDR (gdbarch_read_pc_ftype) (readable_regcache *regcache); 260extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, readable_regcache *regcache); 261extern void set_gdbarch_read_pc (struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc); 262 263extern int gdbarch_write_pc_p (struct gdbarch *gdbarch); 264 265typedef void (gdbarch_write_pc_ftype) (struct regcache *regcache, CORE_ADDR val); 266extern void gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val); 267extern void set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc); 268 269/* Function for getting target's idea of a frame pointer. FIXME: GDB's 270 whole scheme for dealing with "frames" and "frame pointers" needs a 271 serious shakedown. */ 272 273typedef void (gdbarch_virtual_frame_pointer_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset); 274extern void gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset); 275extern void set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer); 276 277extern int gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch); 278 279typedef enum register_status (gdbarch_pseudo_register_read_ftype) (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum, gdb_byte *buf); 280extern enum register_status gdbarch_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum, gdb_byte *buf); 281extern void set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read); 282 283/* Read a register into a new struct value. If the register is wholly 284 or partly unavailable, this should call mark_value_bytes_unavailable 285 as appropriate. If this is defined, then pseudo_register_read will 286 never be called. */ 287 288extern int gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch); 289 290typedef struct value * (gdbarch_pseudo_register_read_value_ftype) (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum); 291extern struct value * gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum); 292extern void set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value); 293 294extern int gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch); 295 296typedef void (gdbarch_pseudo_register_write_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf); 297extern void gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf); 298extern void set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write); 299 300extern int gdbarch_num_regs (struct gdbarch *gdbarch); 301extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs); 302 303/* This macro gives the number of pseudo-registers that live in the 304 register namespace but do not get fetched or stored on the target. 305 These pseudo-registers may be aliases for other registers, 306 combinations of other registers, or they may be computed by GDB. */ 307 308extern int gdbarch_num_pseudo_regs (struct gdbarch *gdbarch); 309extern void set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, int num_pseudo_regs); 310 311/* Assemble agent expression bytecode to collect pseudo-register REG. 312 Return -1 if something goes wrong, 0 otherwise. */ 313 314extern int gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch); 315 316typedef int (gdbarch_ax_pseudo_register_collect_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg); 317extern int gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg); 318extern void set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect); 319 320/* Assemble agent expression bytecode to push the value of pseudo-register 321 REG on the interpreter stack. 322 Return -1 if something goes wrong, 0 otherwise. */ 323 324extern int gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch); 325 326typedef int (gdbarch_ax_pseudo_register_push_stack_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg); 327extern int gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg); 328extern void set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack); 329 330/* Some architectures can display additional information for specific 331 signals. 332 UIOUT is the output stream where the handler will place information. */ 333 334extern int gdbarch_report_signal_info_p (struct gdbarch *gdbarch); 335 336typedef void (gdbarch_report_signal_info_ftype) (struct gdbarch *gdbarch, struct ui_out *uiout, enum gdb_signal siggnal); 337extern void gdbarch_report_signal_info (struct gdbarch *gdbarch, struct ui_out *uiout, enum gdb_signal siggnal); 338extern void set_gdbarch_report_signal_info (struct gdbarch *gdbarch, gdbarch_report_signal_info_ftype *report_signal_info); 339 340/* GDB's standard (or well known) register numbers. These can map onto 341 a real register or a pseudo (computed) register or not be defined at 342 all (-1). 343 gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP. */ 344 345extern int gdbarch_sp_regnum (struct gdbarch *gdbarch); 346extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum); 347 348extern int gdbarch_pc_regnum (struct gdbarch *gdbarch); 349extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum); 350 351extern int gdbarch_ps_regnum (struct gdbarch *gdbarch); 352extern void set_gdbarch_ps_regnum (struct gdbarch *gdbarch, int ps_regnum); 353 354extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch); 355extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum); 356 357/* Convert stab register number (from `r' declaration) to a gdb REGNUM. */ 358 359typedef int (gdbarch_stab_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int stab_regnr); 360extern int gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr); 361extern void set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum); 362 363/* Provide a default mapping from a ecoff register number to a gdb REGNUM. */ 364 365typedef int (gdbarch_ecoff_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int ecoff_regnr); 366extern int gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr); 367extern void set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum); 368 369/* Convert from an sdb register number to an internal gdb register number. */ 370 371typedef int (gdbarch_sdb_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int sdb_regnr); 372extern int gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr); 373extern void set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum); 374 375/* Provide a default mapping from a DWARF2 register number to a gdb REGNUM. 376 Return -1 for bad REGNUM. Note: Several targets get this wrong. */ 377 378typedef int (gdbarch_dwarf2_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int dwarf2_regnr); 379extern int gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr); 380extern void set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum); 381 382typedef const char * (gdbarch_register_name_ftype) (struct gdbarch *gdbarch, int regnr); 383extern const char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr); 384extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name); 385 386/* Return the type of a register specified by the architecture. Only 387 the register cache should call this function directly; others should 388 use "register_type". */ 389 390extern int gdbarch_register_type_p (struct gdbarch *gdbarch); 391 392typedef struct type * (gdbarch_register_type_ftype) (struct gdbarch *gdbarch, int reg_nr); 393extern struct type * gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr); 394extern void set_gdbarch_register_type (struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type); 395 396/* Generate a dummy frame_id for THIS_FRAME assuming that the frame is 397 a dummy frame. A dummy frame is created before an inferior call, 398 the frame_id returned here must match the frame_id that was built 399 for the inferior call. Usually this means the returned frame_id's 400 stack address should match the address returned by 401 gdbarch_push_dummy_call, and the returned frame_id's code address 402 should match the address at which the breakpoint was set in the dummy 403 frame. */ 404 405typedef struct frame_id (gdbarch_dummy_id_ftype) (struct gdbarch *gdbarch, struct frame_info *this_frame); 406extern struct frame_id gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame); 407extern void set_gdbarch_dummy_id (struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id); 408 409/* Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete 410 deprecated_fp_regnum. */ 411 412extern int gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch); 413extern void set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch, int deprecated_fp_regnum); 414 415extern int gdbarch_push_dummy_call_p (struct gdbarch *gdbarch); 416 417typedef 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, function_call_return_method return_method, CORE_ADDR struct_addr); 418extern 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, function_call_return_method return_method, CORE_ADDR struct_addr); 419extern void set_gdbarch_push_dummy_call (struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call); 420 421extern int gdbarch_call_dummy_location (struct gdbarch *gdbarch); 422extern void set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, int call_dummy_location); 423 424extern int gdbarch_push_dummy_code_p (struct gdbarch *gdbarch); 425 426typedef 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); 427extern 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); 428extern void set_gdbarch_push_dummy_code (struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype *push_dummy_code); 429 430/* Return true if the code of FRAME is writable. */ 431 432typedef int (gdbarch_code_of_frame_writable_ftype) (struct gdbarch *gdbarch, struct frame_info *frame); 433extern int gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, struct frame_info *frame); 434extern void set_gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, gdbarch_code_of_frame_writable_ftype *code_of_frame_writable); 435 436typedef void (gdbarch_print_registers_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all); 437extern void gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all); 438extern void set_gdbarch_print_registers_info (struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype *print_registers_info); 439 440typedef void (gdbarch_print_float_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args); 441extern void gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args); 442extern void set_gdbarch_print_float_info (struct gdbarch *gdbarch, gdbarch_print_float_info_ftype *print_float_info); 443 444extern int gdbarch_print_vector_info_p (struct gdbarch *gdbarch); 445 446typedef void (gdbarch_print_vector_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args); 447extern void gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args); 448extern void set_gdbarch_print_vector_info (struct gdbarch *gdbarch, gdbarch_print_vector_info_ftype *print_vector_info); 449 450/* MAP a GDB RAW register number onto a simulator register number. See 451 also include/...-sim.h. */ 452 453typedef int (gdbarch_register_sim_regno_ftype) (struct gdbarch *gdbarch, int reg_nr); 454extern int gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr); 455extern void set_gdbarch_register_sim_regno (struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype *register_sim_regno); 456 457typedef int (gdbarch_cannot_fetch_register_ftype) (struct gdbarch *gdbarch, int regnum); 458extern int gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum); 459extern void set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, gdbarch_cannot_fetch_register_ftype *cannot_fetch_register); 460 461typedef int (gdbarch_cannot_store_register_ftype) (struct gdbarch *gdbarch, int regnum); 462extern int gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum); 463extern void set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype *cannot_store_register); 464 465/* Determine the address where a longjmp will land and save this address 466 in PC. Return nonzero on success. 467 468 FRAME corresponds to the longjmp frame. */ 469 470extern int gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch); 471 472typedef int (gdbarch_get_longjmp_target_ftype) (struct frame_info *frame, CORE_ADDR *pc); 473extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc); 474extern void set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target); 475 476extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch); 477extern void set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, int believe_pcc_promotion); 478 479typedef int (gdbarch_convert_register_p_ftype) (struct gdbarch *gdbarch, int regnum, struct type *type); 480extern int gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type); 481extern void set_gdbarch_convert_register_p (struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype *convert_register_p); 482 483typedef int (gdbarch_register_to_value_ftype) (struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep); 484extern int gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep); 485extern void set_gdbarch_register_to_value (struct gdbarch *gdbarch, gdbarch_register_to_value_ftype *register_to_value); 486 487typedef void (gdbarch_value_to_register_ftype) (struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf); 488extern void gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf); 489extern void set_gdbarch_value_to_register (struct gdbarch *gdbarch, gdbarch_value_to_register_ftype *value_to_register); 490 491/* Construct a value representing the contents of register REGNUM in 492 frame FRAME_ID, interpreted as type TYPE. The routine needs to 493 allocate and return a struct value with all value attributes 494 (but not the value contents) filled in. */ 495 496typedef struct value * (gdbarch_value_from_register_ftype) (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id); 497extern struct value * gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id); 498extern void set_gdbarch_value_from_register (struct gdbarch *gdbarch, gdbarch_value_from_register_ftype *value_from_register); 499 500typedef CORE_ADDR (gdbarch_pointer_to_address_ftype) (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf); 501extern CORE_ADDR gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf); 502extern void set_gdbarch_pointer_to_address (struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address); 503 504typedef void (gdbarch_address_to_pointer_ftype) (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr); 505extern void gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr); 506extern void set_gdbarch_address_to_pointer (struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer); 507 508extern int gdbarch_integer_to_address_p (struct gdbarch *gdbarch); 509 510typedef CORE_ADDR (gdbarch_integer_to_address_ftype) (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf); 511extern CORE_ADDR gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf); 512extern void set_gdbarch_integer_to_address (struct gdbarch *gdbarch, gdbarch_integer_to_address_ftype *integer_to_address); 513 514/* Return the return-value convention that will be used by FUNCTION 515 to return a value of type VALTYPE. FUNCTION may be NULL in which 516 case the return convention is computed based only on VALTYPE. 517 518 If READBUF is not NULL, extract the return value and save it in this buffer. 519 520 If WRITEBUF is not NULL, it contains a return value which will be 521 stored into the appropriate register. This can be used when we want 522 to force the value returned by a function (see the "return" command 523 for instance). */ 524 525extern int gdbarch_return_value_p (struct gdbarch *gdbarch); 526 527typedef 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); 528extern 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); 529extern void set_gdbarch_return_value (struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value); 530 531/* Return true if the return value of function is stored in the first hidden 532 parameter. In theory, this feature should be language-dependent, specified 533 by language and its ABI, such as C++. Unfortunately, compiler may 534 implement it to a target-dependent feature. So that we need such hook here 535 to be aware of this in GDB. */ 536 537typedef int (gdbarch_return_in_first_hidden_param_p_ftype) (struct gdbarch *gdbarch, struct type *type); 538extern int gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, struct type *type); 539extern 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); 540 541typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip); 542extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip); 543extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue); 544 545extern int gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch); 546 547typedef CORE_ADDR (gdbarch_skip_main_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip); 548extern CORE_ADDR gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip); 549extern void set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype *skip_main_prologue); 550 551/* On some platforms, a single function may provide multiple entry points, 552 e.g. one that is used for function-pointer calls and a different one 553 that is used for direct function calls. 554 In order to ensure that breakpoints set on the function will trigger 555 no matter via which entry point the function is entered, a platform 556 may provide the skip_entrypoint callback. It is called with IP set 557 to the main entry point of a function (as determined by the symbol table), 558 and should return the address of the innermost entry point, where the 559 actual breakpoint needs to be set. Note that skip_entrypoint is used 560 by GDB common code even when debugging optimized code, where skip_prologue 561 is not used. */ 562 563extern int gdbarch_skip_entrypoint_p (struct gdbarch *gdbarch); 564 565typedef CORE_ADDR (gdbarch_skip_entrypoint_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip); 566extern CORE_ADDR gdbarch_skip_entrypoint (struct gdbarch *gdbarch, CORE_ADDR ip); 567extern void set_gdbarch_skip_entrypoint (struct gdbarch *gdbarch, gdbarch_skip_entrypoint_ftype *skip_entrypoint); 568 569typedef int (gdbarch_inner_than_ftype) (CORE_ADDR lhs, CORE_ADDR rhs); 570extern int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs); 571extern void set_gdbarch_inner_than (struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than); 572 573typedef const gdb_byte * (gdbarch_breakpoint_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr); 574extern const gdb_byte * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr); 575extern void set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc); 576 577/* Return the breakpoint kind for this target based on *PCPTR. */ 578 579typedef int (gdbarch_breakpoint_kind_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr); 580extern int gdbarch_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr); 581extern void set_gdbarch_breakpoint_kind_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc); 582 583/* Return the software breakpoint from KIND. KIND can have target 584 specific meaning like the Z0 kind parameter. 585 SIZE is set to the software breakpoint's length in memory. */ 586 587typedef const gdb_byte * (gdbarch_sw_breakpoint_from_kind_ftype) (struct gdbarch *gdbarch, int kind, int *size); 588extern const gdb_byte * gdbarch_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size); 589extern void set_gdbarch_sw_breakpoint_from_kind (struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind); 590 591/* Return the breakpoint kind for this target based on the current 592 processor state (e.g. the current instruction mode on ARM) and the 593 *PCPTR. In default, it is gdbarch->breakpoint_kind_from_pc. */ 594 595typedef int (gdbarch_breakpoint_kind_from_current_state_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR *pcptr); 596extern int gdbarch_breakpoint_kind_from_current_state (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR *pcptr); 597extern void set_gdbarch_breakpoint_kind_from_current_state (struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_current_state_ftype *breakpoint_kind_from_current_state); 598 599extern int gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch); 600 601typedef CORE_ADDR (gdbarch_adjust_breakpoint_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR bpaddr); 602extern CORE_ADDR gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr); 603extern void set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address); 604 605typedef int (gdbarch_memory_insert_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt); 606extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt); 607extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint); 608 609typedef int (gdbarch_memory_remove_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt); 610extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt); 611extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint); 612 613extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch); 614extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break); 615 616/* A function can be addressed by either it's "pointer" (possibly a 617 descriptor address) or "entry point" (first executable instruction). 618 The method "convert_from_func_ptr_addr" converting the former to the 619 latter. gdbarch_deprecated_function_start_offset is being used to implement 620 a simplified subset of that functionality - the function's address 621 corresponds to the "function pointer" and the function's start 622 corresponds to the "function entry point" - and hence is redundant. */ 623 624extern CORE_ADDR gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch); 625extern void set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_function_start_offset); 626 627/* Return the remote protocol register number associated with this 628 register. Normally the identity mapping. */ 629 630typedef int (gdbarch_remote_register_number_ftype) (struct gdbarch *gdbarch, int regno); 631extern int gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno); 632extern void set_gdbarch_remote_register_number (struct gdbarch *gdbarch, gdbarch_remote_register_number_ftype *remote_register_number); 633 634/* Fetch the target specific address used to represent a load module. */ 635 636extern int gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch); 637 638typedef CORE_ADDR (gdbarch_fetch_tls_load_module_address_ftype) (struct objfile *objfile); 639extern CORE_ADDR gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile); 640extern void set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address); 641 642/* Return the thread-local address at OFFSET in the thread-local 643 storage for the thread PTID and the shared library or executable 644 file given by LM_ADDR. If that block of thread-local storage hasn't 645 been allocated yet, this function may throw an error. LM_ADDR may 646 be zero for statically linked multithreaded inferiors. */ 647 648extern int gdbarch_get_thread_local_address_p (struct gdbarch *gdbarch); 649 650typedef CORE_ADDR (gdbarch_get_thread_local_address_ftype) (struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset); 651extern CORE_ADDR gdbarch_get_thread_local_address (struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset); 652extern void set_gdbarch_get_thread_local_address (struct gdbarch *gdbarch, gdbarch_get_thread_local_address_ftype *get_thread_local_address); 653 654extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch); 655extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip); 656 657typedef CORE_ADDR (gdbarch_unwind_pc_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame); 658extern CORE_ADDR gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame); 659extern void set_gdbarch_unwind_pc (struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype *unwind_pc); 660 661typedef CORE_ADDR (gdbarch_unwind_sp_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame); 662extern CORE_ADDR gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame); 663extern void set_gdbarch_unwind_sp (struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype *unwind_sp); 664 665/* DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame 666 frame-base. Enable frame-base before frame-unwind. */ 667 668extern int gdbarch_frame_num_args_p (struct gdbarch *gdbarch); 669 670typedef int (gdbarch_frame_num_args_ftype) (struct frame_info *frame); 671extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame); 672extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args); 673 674extern int gdbarch_frame_align_p (struct gdbarch *gdbarch); 675 676typedef CORE_ADDR (gdbarch_frame_align_ftype) (struct gdbarch *gdbarch, CORE_ADDR address); 677extern CORE_ADDR gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address); 678extern void set_gdbarch_frame_align (struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align); 679 680typedef int (gdbarch_stabs_argument_has_addr_ftype) (struct gdbarch *gdbarch, struct type *type); 681extern int gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type); 682extern void set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr); 683 684extern int gdbarch_frame_red_zone_size (struct gdbarch *gdbarch); 685extern void set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch, int frame_red_zone_size); 686 687typedef CORE_ADDR (gdbarch_convert_from_func_ptr_addr_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ); 688extern CORE_ADDR gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ); 689extern void set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr); 690 691/* On some machines there are bits in addresses which are not really 692 part of the address, but are used by the kernel, the hardware, etc. 693 for special purposes. gdbarch_addr_bits_remove takes out any such bits so 694 we get a "real" address such as one would find in a symbol table. 695 This is used only for addresses of instructions, and even then I'm 696 not sure it's used in all contexts. It exists to deal with there 697 being a few stray bits in the PC which would mislead us, not as some 698 sort of generic thing to handle alignment or segmentation (it's 699 possible it should be in TARGET_READ_PC instead). */ 700 701typedef CORE_ADDR (gdbarch_addr_bits_remove_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); 702extern CORE_ADDR gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr); 703extern void set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype *addr_bits_remove); 704 705/* On some machines, not all bits of an address word are significant. 706 For example, on AArch64, the top bits of an address known as the "tag" 707 are ignored by the kernel, the hardware, etc. and can be regarded as 708 additional data associated with the address. */ 709 710extern int gdbarch_significant_addr_bit (struct gdbarch *gdbarch); 711extern void set_gdbarch_significant_addr_bit (struct gdbarch *gdbarch, int significant_addr_bit); 712 713/* FIXME/cagney/2001-01-18: This should be split in two. A target method that 714 indicates if the target needs software single step. An ISA method to 715 implement it. 716 717 FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the 718 target can single step. If not, then implement single step using breakpoints. 719 720 Return a vector of addresses on which the software single step 721 breakpoints should be inserted. NULL means software single step is 722 not used. 723 Multiple breakpoints may be inserted for some instructions such as 724 conditional branch. However, each implementation must always evaluate 725 the condition and only put the breakpoint at the branch destination if 726 the condition is true, so that we ensure forward progress when stepping 727 past a conditional branch to self. */ 728 729extern int gdbarch_software_single_step_p (struct gdbarch *gdbarch); 730 731typedef std::vector<CORE_ADDR> (gdbarch_software_single_step_ftype) (struct regcache *regcache); 732extern std::vector<CORE_ADDR> gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache); 733extern void set_gdbarch_software_single_step (struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step); 734 735/* Return non-zero if the processor is executing a delay slot and a 736 further single-step is needed before the instruction finishes. */ 737 738extern int gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch); 739 740typedef int (gdbarch_single_step_through_delay_ftype) (struct gdbarch *gdbarch, struct frame_info *frame); 741extern int gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame); 742extern void set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch, gdbarch_single_step_through_delay_ftype *single_step_through_delay); 743 744/* FIXME: cagney/2003-08-28: Need to find a better way of selecting the 745 disassembler. Perhaps objdump can handle it? */ 746 747typedef int (gdbarch_print_insn_ftype) (bfd_vma vma, struct disassemble_info *info); 748extern int gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info); 749extern void set_gdbarch_print_insn (struct gdbarch *gdbarch, gdbarch_print_insn_ftype *print_insn); 750 751typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (struct frame_info *frame, CORE_ADDR pc); 752extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc); 753extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code); 754 755/* If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER 756 evaluates non-zero, this is the address where the debugger will place 757 a step-resume breakpoint to get us past the dynamic linker. */ 758 759typedef CORE_ADDR (gdbarch_skip_solib_resolver_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc); 760extern CORE_ADDR gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc); 761extern void set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype *skip_solib_resolver); 762 763/* Some systems also have trampoline code for returning from shared libs. */ 764 765typedef int (gdbarch_in_solib_return_trampoline_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name); 766extern int gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name); 767extern void set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline); 768 769/* Return true if PC lies inside an indirect branch thunk. */ 770 771typedef bool (gdbarch_in_indirect_branch_thunk_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc); 772extern bool gdbarch_in_indirect_branch_thunk (struct gdbarch *gdbarch, CORE_ADDR pc); 773extern void set_gdbarch_in_indirect_branch_thunk (struct gdbarch *gdbarch, gdbarch_in_indirect_branch_thunk_ftype *in_indirect_branch_thunk); 774 775/* A target might have problems with watchpoints as soon as the stack 776 frame of the current function has been destroyed. This mostly happens 777 as the first action in a function's epilogue. stack_frame_destroyed_p() 778 is defined to return a non-zero value if either the given addr is one 779 instruction after the stack destroying instruction up to the trailing 780 return instruction or if we can figure out that the stack frame has 781 already been invalidated regardless of the value of addr. Targets 782 which don't suffer from that problem could just let this functionality 783 untouched. */ 784 785typedef int (gdbarch_stack_frame_destroyed_p_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); 786extern int gdbarch_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR addr); 787extern void set_gdbarch_stack_frame_destroyed_p (struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype *stack_frame_destroyed_p); 788 789/* Process an ELF symbol in the minimal symbol table in a backend-specific 790 way. Normally this hook is supposed to do nothing, however if required, 791 then this hook can be used to apply tranformations to symbols that are 792 considered special in some way. For example the MIPS backend uses it 793 to interpret `st_other' information to mark compressed code symbols so 794 that they can be treated in the appropriate manner in the processing of 795 the main symbol table and DWARF-2 records. */ 796 797extern int gdbarch_elf_make_msymbol_special_p (struct gdbarch *gdbarch); 798 799typedef void (gdbarch_elf_make_msymbol_special_ftype) (asymbol *sym, struct minimal_symbol *msym); 800extern void gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym); 801extern void set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special); 802 803typedef void (gdbarch_coff_make_msymbol_special_ftype) (int val, struct minimal_symbol *msym); 804extern void gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym); 805extern void set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special); 806 807/* Process a symbol in the main symbol table in a backend-specific way. 808 Normally this hook is supposed to do nothing, however if required, 809 then this hook can be used to apply tranformations to symbols that 810 are considered special in some way. This is currently used by the 811 MIPS backend to make sure compressed code symbols have the ISA bit 812 set. This in turn is needed for symbol values seen in GDB to match 813 the values used at the runtime by the program itself, for function 814 and label references. */ 815 816typedef void (gdbarch_make_symbol_special_ftype) (struct symbol *sym, struct objfile *objfile); 817extern void gdbarch_make_symbol_special (struct gdbarch *gdbarch, struct symbol *sym, struct objfile *objfile); 818extern void set_gdbarch_make_symbol_special (struct gdbarch *gdbarch, gdbarch_make_symbol_special_ftype *make_symbol_special); 819 820/* Adjust the address retrieved from a DWARF-2 record other than a line 821 entry in a backend-specific way. Normally this hook is supposed to 822 return the address passed unchanged, however if that is incorrect for 823 any reason, then this hook can be used to fix the address up in the 824 required manner. This is currently used by the MIPS backend to make 825 sure addresses in FDE, range records, etc. referring to compressed 826 code have the ISA bit set, matching line information and the symbol 827 table. */ 828 829typedef CORE_ADDR (gdbarch_adjust_dwarf2_addr_ftype) (CORE_ADDR pc); 830extern CORE_ADDR gdbarch_adjust_dwarf2_addr (struct gdbarch *gdbarch, CORE_ADDR pc); 831extern void set_gdbarch_adjust_dwarf2_addr (struct gdbarch *gdbarch, gdbarch_adjust_dwarf2_addr_ftype *adjust_dwarf2_addr); 832 833/* Adjust the address updated by a line entry in a backend-specific way. 834 Normally this hook is supposed to return the address passed unchanged, 835 however in the case of inconsistencies in these records, this hook can 836 be used to fix them up in the required manner. This is currently used 837 by the MIPS backend to make sure all line addresses in compressed code 838 are presented with the ISA bit set, which is not always the case. This 839 in turn ensures breakpoint addresses are correctly matched against the 840 stop PC. */ 841 842typedef CORE_ADDR (gdbarch_adjust_dwarf2_line_ftype) (CORE_ADDR addr, int rel); 843extern CORE_ADDR gdbarch_adjust_dwarf2_line (struct gdbarch *gdbarch, CORE_ADDR addr, int rel); 844extern void set_gdbarch_adjust_dwarf2_line (struct gdbarch *gdbarch, gdbarch_adjust_dwarf2_line_ftype *adjust_dwarf2_line); 845 846extern int gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch); 847extern void set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, int cannot_step_breakpoint); 848 849/* See comment in target.h about continuable, steppable and 850 non-steppable watchpoints. */ 851 852extern int gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch); 853extern void set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, int have_nonsteppable_watchpoint); 854 855extern int gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch); 856 857typedef int (gdbarch_address_class_type_flags_ftype) (int byte_size, int dwarf2_addr_class); 858extern int gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class); 859extern void set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags); 860 861extern int gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch); 862 863typedef const char * (gdbarch_address_class_type_flags_to_name_ftype) (struct gdbarch *gdbarch, int type_flags); 864extern const char * gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags); 865extern 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); 866 867/* Execute vendor-specific DWARF Call Frame Instruction. OP is the instruction. 868 FS are passed from the generic execute_cfa_program function. */ 869 870typedef bool (gdbarch_execute_dwarf_cfa_vendor_op_ftype) (struct gdbarch *gdbarch, gdb_byte op, struct dwarf2_frame_state *fs); 871extern bool gdbarch_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_byte op, struct dwarf2_frame_state *fs); 872extern void set_gdbarch_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdbarch_execute_dwarf_cfa_vendor_op_ftype *execute_dwarf_cfa_vendor_op); 873 874/* Return the appropriate type_flags for the supplied address class. 875 This function should return 1 if the address class was recognized and 876 type_flags was set, zero otherwise. */ 877 878extern int gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch); 879 880typedef int (gdbarch_address_class_name_to_type_flags_ftype) (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr); 881extern int gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr); 882extern 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); 883 884/* Is a register in a group */ 885 886typedef int (gdbarch_register_reggroup_p_ftype) (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup); 887extern int gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup); 888extern void set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p); 889 890/* Fetch the pointer to the ith function argument. */ 891 892extern int gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch); 893 894typedef CORE_ADDR (gdbarch_fetch_pointer_argument_ftype) (struct frame_info *frame, int argi, struct type *type); 895extern CORE_ADDR gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type); 896extern void set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument); 897 898/* Iterate over all supported register notes in a core file. For each 899 supported register note section, the iterator must call CB and pass 900 CB_DATA unchanged. If REGCACHE is not NULL, the iterator can limit 901 the supported register note sections based on the current register 902 values. Otherwise it should enumerate all supported register note 903 sections. */ 904 905extern int gdbarch_iterate_over_regset_sections_p (struct gdbarch *gdbarch); 906 907typedef void (gdbarch_iterate_over_regset_sections_ftype) (struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache); 908extern void gdbarch_iterate_over_regset_sections (struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache); 909extern void set_gdbarch_iterate_over_regset_sections (struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections); 910 911/* Create core file notes */ 912 913extern int gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch); 914 915typedef char * (gdbarch_make_corefile_notes_ftype) (struct gdbarch *gdbarch, bfd *obfd, int *note_size); 916extern char * gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size); 917extern void set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch, gdbarch_make_corefile_notes_ftype *make_corefile_notes); 918 919/* Find core file memory regions */ 920 921extern int gdbarch_find_memory_regions_p (struct gdbarch *gdbarch); 922 923typedef int (gdbarch_find_memory_regions_ftype) (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data); 924extern int gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data); 925extern void set_gdbarch_find_memory_regions (struct gdbarch *gdbarch, gdbarch_find_memory_regions_ftype *find_memory_regions); 926 927/* Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from 928 core file into buffer READBUF with length LEN. Return the number of bytes read 929 (zero indicates failure). 930 failed, otherwise, return the red length of READBUF. */ 931 932extern int gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch); 933 934typedef ULONGEST (gdbarch_core_xfer_shared_libraries_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len); 935extern ULONGEST gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len); 936extern void set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries); 937 938/* Read offset OFFSET of TARGET_OBJECT_LIBRARIES_AIX formatted shared 939 libraries list from core file into buffer READBUF with length LEN. 940 Return the number of bytes read (zero indicates failure). */ 941 942extern int gdbarch_core_xfer_shared_libraries_aix_p (struct gdbarch *gdbarch); 943 944typedef ULONGEST (gdbarch_core_xfer_shared_libraries_aix_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len); 945extern ULONGEST gdbarch_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len); 946extern void set_gdbarch_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch, gdbarch_core_xfer_shared_libraries_aix_ftype *core_xfer_shared_libraries_aix); 947 948/* How the core target converts a PTID from a core file to a string. */ 949 950extern int gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch); 951 952typedef std::string (gdbarch_core_pid_to_str_ftype) (struct gdbarch *gdbarch, ptid_t ptid); 953extern std::string gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid); 954extern void set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch, gdbarch_core_pid_to_str_ftype *core_pid_to_str); 955 956/* How the core target extracts the name of a thread from a core file. */ 957 958extern int gdbarch_core_thread_name_p (struct gdbarch *gdbarch); 959 960typedef const char * (gdbarch_core_thread_name_ftype) (struct gdbarch *gdbarch, struct thread_info *thr); 961extern const char * gdbarch_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr); 962extern void set_gdbarch_core_thread_name (struct gdbarch *gdbarch, gdbarch_core_thread_name_ftype *core_thread_name); 963 964/* Read offset OFFSET of TARGET_OBJECT_SIGNAL_INFO signal information 965 from core file into buffer READBUF with length LEN. Return the number 966 of bytes read (zero indicates EOF, a negative value indicates failure). */ 967 968extern int gdbarch_core_xfer_siginfo_p (struct gdbarch *gdbarch); 969 970typedef LONGEST (gdbarch_core_xfer_siginfo_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len); 971extern LONGEST gdbarch_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len); 972extern void set_gdbarch_core_xfer_siginfo (struct gdbarch *gdbarch, gdbarch_core_xfer_siginfo_ftype *core_xfer_siginfo); 973 974/* BFD target to use when generating a core file. */ 975 976extern int gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch); 977 978extern const char * gdbarch_gcore_bfd_target (struct gdbarch *gdbarch); 979extern void set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch, const char * gcore_bfd_target); 980 981/* If the elements of C++ vtables are in-place function descriptors rather 982 than normal function pointers (which may point to code or a descriptor), 983 set this to one. */ 984 985extern int gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch); 986extern void set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch, int vtable_function_descriptors); 987 988/* Set if the least significant bit of the delta is used instead of the least 989 significant bit of the pfn for pointers to virtual member functions. */ 990 991extern int gdbarch_vbit_in_delta (struct gdbarch *gdbarch); 992extern void set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch, int vbit_in_delta); 993 994/* Advance PC to next instruction in order to skip a permanent breakpoint. */ 995 996typedef void (gdbarch_skip_permanent_breakpoint_ftype) (struct regcache *regcache); 997extern void gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache); 998extern void set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint); 999 1000/* The maximum length of an instruction on this architecture in bytes. */ 1001 1002extern int gdbarch_max_insn_length_p (struct gdbarch *gdbarch); 1003 1004extern ULONGEST gdbarch_max_insn_length (struct gdbarch *gdbarch); 1005extern void set_gdbarch_max_insn_length (struct gdbarch *gdbarch, ULONGEST max_insn_length); 1006 1007/* Copy the instruction at FROM to TO, and make any adjustments 1008 necessary to single-step it at that address. 1009 1010 REGS holds the state the thread's registers will have before 1011 executing the copied instruction; the PC in REGS will refer to FROM, 1012 not the copy at TO. The caller should update it to point at TO later. 1013 1014 Return a pointer to data of the architecture's choice to be passed 1015 to gdbarch_displaced_step_fixup. 1016 1017 For a general explanation of displaced stepping and how GDB uses it, 1018 see the comments in infrun.c. 1019 1020 The TO area is only guaranteed to have space for 1021 gdbarch_max_insn_length (arch) bytes, so this function must not 1022 write more bytes than that to that area. 1023 1024 If you do not provide this function, GDB assumes that the 1025 architecture does not support displaced stepping. 1026 1027 If the instruction cannot execute out of line, return NULL. The 1028 core falls back to stepping past the instruction in-line instead in 1029 that case. */ 1030 1031extern int gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch); 1032 1033typedef displaced_step_closure_up (gdbarch_displaced_step_copy_insn_ftype) (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs); 1034extern displaced_step_closure_up gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs); 1035extern void set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn); 1036 1037/* Return true if GDB should use hardware single-stepping to execute 1038 the displaced instruction identified by CLOSURE. If false, 1039 GDB will simply restart execution at the displaced instruction 1040 location, and it is up to the target to ensure GDB will receive 1041 control again (e.g. by placing a software breakpoint instruction 1042 into the displaced instruction buffer). 1043 1044 The default implementation returns false on all targets that 1045 provide a gdbarch_software_single_step routine, and true otherwise. */ 1046 1047typedef int (gdbarch_displaced_step_hw_singlestep_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure); 1048extern int gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure); 1049extern void set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep); 1050 1051/* Fix up the state resulting from successfully single-stepping a 1052 displaced instruction, to give the result we would have gotten from 1053 stepping the instruction in its original location. 1054 1055 REGS is the register state resulting from single-stepping the 1056 displaced instruction. 1057 1058 CLOSURE is the result from the matching call to 1059 gdbarch_displaced_step_copy_insn. 1060 1061 If you provide gdbarch_displaced_step_copy_insn.but not this 1062 function, then GDB assumes that no fixup is needed after 1063 single-stepping the instruction. 1064 1065 For a general explanation of displaced stepping and how GDB uses it, 1066 see the comments in infrun.c. */ 1067 1068extern int gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch); 1069 1070typedef void (gdbarch_displaced_step_fixup_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs); 1071extern void gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs); 1072extern void set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype *displaced_step_fixup); 1073 1074/* Return the address of an appropriate place to put displaced 1075 instructions while we step over them. There need only be one such 1076 place, since we're only stepping one thread over a breakpoint at a 1077 time. 1078 1079 For a general explanation of displaced stepping and how GDB uses it, 1080 see the comments in infrun.c. */ 1081 1082typedef CORE_ADDR (gdbarch_displaced_step_location_ftype) (struct gdbarch *gdbarch); 1083extern CORE_ADDR gdbarch_displaced_step_location (struct gdbarch *gdbarch); 1084extern void set_gdbarch_displaced_step_location (struct gdbarch *gdbarch, gdbarch_displaced_step_location_ftype *displaced_step_location); 1085 1086/* Relocate an instruction to execute at a different address. OLDLOC 1087 is the address in the inferior memory where the instruction to 1088 relocate is currently at. On input, TO points to the destination 1089 where we want the instruction to be copied (and possibly adjusted) 1090 to. On output, it points to one past the end of the resulting 1091 instruction(s). The effect of executing the instruction at TO shall 1092 be the same as if executing it at FROM. For example, call 1093 instructions that implicitly push the return address on the stack 1094 should be adjusted to return to the instruction after OLDLOC; 1095 relative branches, and other PC-relative instructions need the 1096 offset adjusted; etc. */ 1097 1098extern int gdbarch_relocate_instruction_p (struct gdbarch *gdbarch); 1099 1100typedef void (gdbarch_relocate_instruction_ftype) (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from); 1101extern void gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from); 1102extern void set_gdbarch_relocate_instruction (struct gdbarch *gdbarch, gdbarch_relocate_instruction_ftype *relocate_instruction); 1103 1104/* Refresh overlay mapped state for section OSECT. */ 1105 1106extern int gdbarch_overlay_update_p (struct gdbarch *gdbarch); 1107 1108typedef void (gdbarch_overlay_update_ftype) (struct obj_section *osect); 1109extern void gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect); 1110extern void set_gdbarch_overlay_update (struct gdbarch *gdbarch, gdbarch_overlay_update_ftype *overlay_update); 1111 1112extern int gdbarch_core_read_description_p (struct gdbarch *gdbarch); 1113 1114typedef const struct target_desc * (gdbarch_core_read_description_ftype) (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd); 1115extern const struct target_desc * gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd); 1116extern void set_gdbarch_core_read_description (struct gdbarch *gdbarch, gdbarch_core_read_description_ftype *core_read_description); 1117 1118/* Set if the address in N_SO or N_FUN stabs may be zero. */ 1119 1120extern int gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch); 1121extern void set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch, int sofun_address_maybe_missing); 1122 1123/* Parse the instruction at ADDR storing in the record execution log 1124 the registers REGCACHE and memory ranges that will be affected when 1125 the instruction executes, along with their current values. 1126 Return -1 if something goes wrong, 0 otherwise. */ 1127 1128extern int gdbarch_process_record_p (struct gdbarch *gdbarch); 1129 1130typedef int (gdbarch_process_record_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr); 1131extern int gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr); 1132extern void set_gdbarch_process_record (struct gdbarch *gdbarch, gdbarch_process_record_ftype *process_record); 1133 1134/* Save process state after a signal. 1135 Return -1 if something goes wrong, 0 otherwise. */ 1136 1137extern int gdbarch_process_record_signal_p (struct gdbarch *gdbarch); 1138 1139typedef int (gdbarch_process_record_signal_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal); 1140extern int gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal); 1141extern void set_gdbarch_process_record_signal (struct gdbarch *gdbarch, gdbarch_process_record_signal_ftype *process_record_signal); 1142 1143/* Signal translation: translate inferior's signal (target's) number 1144 into GDB's representation. The implementation of this method must 1145 be host independent. IOW, don't rely on symbols of the NAT_FILE 1146 header (the nm-*.h files), the host <signal.h> header, or similar 1147 headers. This is mainly used when cross-debugging core files --- 1148 "Live" targets hide the translation behind the target interface 1149 (target_wait, target_resume, etc.). */ 1150 1151extern int gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch); 1152 1153typedef enum gdb_signal (gdbarch_gdb_signal_from_target_ftype) (struct gdbarch *gdbarch, int signo); 1154extern enum gdb_signal gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, int signo); 1155extern void set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target); 1156 1157/* Signal translation: translate the GDB's internal signal number into 1158 the inferior's signal (target's) representation. The implementation 1159 of this method must be host independent. IOW, don't rely on symbols 1160 of the NAT_FILE header (the nm-*.h files), the host <signal.h> 1161 header, or similar headers. 1162 Return the target signal number if found, or -1 if the GDB internal 1163 signal number is invalid. */ 1164 1165extern int gdbarch_gdb_signal_to_target_p (struct gdbarch *gdbarch); 1166 1167typedef int (gdbarch_gdb_signal_to_target_ftype) (struct gdbarch *gdbarch, enum gdb_signal signal); 1168extern int gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal); 1169extern void set_gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch, gdbarch_gdb_signal_to_target_ftype *gdb_signal_to_target); 1170 1171/* Extra signal info inspection. 1172 1173 Return a type suitable to inspect extra signal information. */ 1174 1175extern int gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch); 1176 1177typedef struct type * (gdbarch_get_siginfo_type_ftype) (struct gdbarch *gdbarch); 1178extern struct type * gdbarch_get_siginfo_type (struct gdbarch *gdbarch); 1179extern void set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch, gdbarch_get_siginfo_type_ftype *get_siginfo_type); 1180 1181/* Record architecture-specific information from the symbol table. */ 1182 1183extern int gdbarch_record_special_symbol_p (struct gdbarch *gdbarch); 1184 1185typedef void (gdbarch_record_special_symbol_ftype) (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym); 1186extern void gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym); 1187extern void set_gdbarch_record_special_symbol (struct gdbarch *gdbarch, gdbarch_record_special_symbol_ftype *record_special_symbol); 1188 1189/* Function for the 'catch syscall' feature. 1190 Get architecture-specific system calls information from registers. */ 1191 1192extern int gdbarch_get_syscall_number_p (struct gdbarch *gdbarch); 1193 1194typedef LONGEST (gdbarch_get_syscall_number_ftype) (struct gdbarch *gdbarch, thread_info *thread); 1195extern LONGEST gdbarch_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread); 1196extern void set_gdbarch_get_syscall_number (struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype *get_syscall_number); 1197 1198/* The filename of the XML syscall for this architecture. */ 1199 1200extern const char * gdbarch_xml_syscall_file (struct gdbarch *gdbarch); 1201extern void set_gdbarch_xml_syscall_file (struct gdbarch *gdbarch, const char * xml_syscall_file); 1202 1203/* Information about system calls from this architecture */ 1204 1205extern struct syscalls_info * gdbarch_syscalls_info (struct gdbarch *gdbarch); 1206extern void set_gdbarch_syscalls_info (struct gdbarch *gdbarch, struct syscalls_info * syscalls_info); 1207 1208/* SystemTap related fields and functions. 1209 A NULL-terminated array of prefixes used to mark an integer constant 1210 on the architecture's assembly. 1211 For example, on x86 integer constants are written as: 1212 1213 $10 ;; integer constant 10 1214 1215 in this case, this prefix would be the character `$'. */ 1216 1217extern const char *const * gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch); 1218extern void set_gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch, const char *const * stap_integer_prefixes); 1219 1220/* A NULL-terminated array of suffixes used to mark an integer constant 1221 on the architecture's assembly. */ 1222 1223extern const char *const * gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch); 1224extern void set_gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch, const char *const * stap_integer_suffixes); 1225 1226/* A NULL-terminated array of prefixes used to mark a register name on 1227 the architecture's assembly. 1228 For example, on x86 the register name is written as: 1229 1230 %eax ;; register eax 1231 1232 in this case, this prefix would be the character `%'. */ 1233 1234extern const char *const * gdbarch_stap_register_prefixes (struct gdbarch *gdbarch); 1235extern void set_gdbarch_stap_register_prefixes (struct gdbarch *gdbarch, const char *const * stap_register_prefixes); 1236 1237/* A NULL-terminated array of suffixes used to mark a register name on 1238 the architecture's assembly. */ 1239 1240extern const char *const * gdbarch_stap_register_suffixes (struct gdbarch *gdbarch); 1241extern void set_gdbarch_stap_register_suffixes (struct gdbarch *gdbarch, const char *const * stap_register_suffixes); 1242 1243/* A NULL-terminated array of prefixes used to mark a register 1244 indirection on the architecture's assembly. 1245 For example, on x86 the register indirection is written as: 1246 1247 (%eax) ;; indirecting eax 1248 1249 in this case, this prefix would be the charater `('. 1250 1251 Please note that we use the indirection prefix also for register 1252 displacement, e.g., `4(%eax)' on x86. */ 1253 1254extern const char *const * gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch); 1255extern void set_gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch, const char *const * stap_register_indirection_prefixes); 1256 1257/* A NULL-terminated array of suffixes used to mark a register 1258 indirection on the architecture's assembly. 1259 For example, on x86 the register indirection is written as: 1260 1261 (%eax) ;; indirecting eax 1262 1263 in this case, this prefix would be the charater `)'. 1264 1265 Please note that we use the indirection suffix also for register 1266 displacement, e.g., `4(%eax)' on x86. */ 1267 1268extern const char *const * gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch); 1269extern void set_gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch, const char *const * stap_register_indirection_suffixes); 1270 1271/* Prefix(es) used to name a register using GDB's nomenclature. 1272 1273 For example, on PPC a register is represented by a number in the assembly 1274 language (e.g., `10' is the 10th general-purpose register). However, 1275 inside GDB this same register has an `r' appended to its name, so the 10th 1276 register would be represented as `r10' internally. */ 1277 1278extern const char * gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch); 1279extern void set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch, const char * stap_gdb_register_prefix); 1280 1281/* Suffix used to name a register using GDB's nomenclature. */ 1282 1283extern const char * gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch); 1284extern void set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch, const char * stap_gdb_register_suffix); 1285 1286/* Check if S is a single operand. 1287 1288 Single operands can be: 1289 - Literal integers, e.g. `$10' on x86 1290 - Register access, e.g. `%eax' on x86 1291 - Register indirection, e.g. `(%eax)' on x86 1292 - Register displacement, e.g. `4(%eax)' on x86 1293 1294 This function should check for these patterns on the string 1295 and return 1 if some were found, or zero otherwise. Please try to match 1296 as much info as you can from the string, i.e., if you have to match 1297 something like `(%', do not match just the `('. */ 1298 1299extern int gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch); 1300 1301typedef int (gdbarch_stap_is_single_operand_ftype) (struct gdbarch *gdbarch, const char *s); 1302extern int gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s); 1303extern void set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand); 1304 1305/* Function used to handle a "special case" in the parser. 1306 1307 A "special case" is considered to be an unknown token, i.e., a token 1308 that the parser does not know how to parse. A good example of special 1309 case would be ARM's register displacement syntax: 1310 1311 [R0, #4] ;; displacing R0 by 4 1312 1313 Since the parser assumes that a register displacement is of the form: 1314 1315 <number> <indirection_prefix> <register_name> <indirection_suffix> 1316 1317 it means that it will not be able to recognize and parse this odd syntax. 1318 Therefore, we should add a special case function that will handle this token. 1319 1320 This function should generate the proper expression form of the expression 1321 using GDB's internal expression mechanism (e.g., `write_exp_elt_opcode' 1322 and so on). It should also return 1 if the parsing was successful, or zero 1323 if the token was not recognized as a special token (in this case, returning 1324 zero means that the special parser is deferring the parsing to the generic 1325 parser), and should advance the buffer pointer (p->arg). */ 1326 1327extern int gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch); 1328 1329typedef int (gdbarch_stap_parse_special_token_ftype) (struct gdbarch *gdbarch, struct stap_parse_info *p); 1330extern int gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p); 1331extern void set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype *stap_parse_special_token); 1332 1333/* Perform arch-dependent adjustments to a register name. 1334 1335 In very specific situations, it may be necessary for the register 1336 name present in a SystemTap probe's argument to be handled in a 1337 special way. For example, on i386, GCC may over-optimize the 1338 register allocation and use smaller registers than necessary. In 1339 such cases, the client that is reading and evaluating the SystemTap 1340 probe (ourselves) will need to actually fetch values from the wider 1341 version of the register in question. 1342 1343 To illustrate the example, consider the following probe argument 1344 (i386): 1345 1346 4@%ax 1347 1348 This argument says that its value can be found at the %ax register, 1349 which is a 16-bit register. However, the argument's prefix says 1350 that its type is "uint32_t", which is 32-bit in size. Therefore, in 1351 this case, GDB should actually fetch the probe's value from register 1352 %eax, not %ax. In this scenario, this function would actually 1353 replace the register name from %ax to %eax. 1354 1355 The rationale for this can be found at PR breakpoints/24541. */ 1356 1357extern int gdbarch_stap_adjust_register_p (struct gdbarch *gdbarch); 1358 1359typedef std::string (gdbarch_stap_adjust_register_ftype) (struct gdbarch *gdbarch, struct stap_parse_info *p, const std::string ®name, int regnum); 1360extern std::string gdbarch_stap_adjust_register (struct gdbarch *gdbarch, struct stap_parse_info *p, const std::string ®name, int regnum); 1361extern void set_gdbarch_stap_adjust_register (struct gdbarch *gdbarch, gdbarch_stap_adjust_register_ftype *stap_adjust_register); 1362 1363/* DTrace related functions. 1364 The expression to compute the NARTGth+1 argument to a DTrace USDT probe. 1365 NARG must be >= 0. */ 1366 1367extern int gdbarch_dtrace_parse_probe_argument_p (struct gdbarch *gdbarch); 1368 1369typedef void (gdbarch_dtrace_parse_probe_argument_ftype) (struct gdbarch *gdbarch, struct expr_builder *builder, int narg); 1370extern void gdbarch_dtrace_parse_probe_argument (struct gdbarch *gdbarch, struct expr_builder *builder, int narg); 1371extern void set_gdbarch_dtrace_parse_probe_argument (struct gdbarch *gdbarch, gdbarch_dtrace_parse_probe_argument_ftype *dtrace_parse_probe_argument); 1372 1373/* True if the given ADDR does not contain the instruction sequence 1374 corresponding to a disabled DTrace is-enabled probe. */ 1375 1376extern int gdbarch_dtrace_probe_is_enabled_p (struct gdbarch *gdbarch); 1377 1378typedef int (gdbarch_dtrace_probe_is_enabled_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); 1379extern int gdbarch_dtrace_probe_is_enabled (struct gdbarch *gdbarch, CORE_ADDR addr); 1380extern void set_gdbarch_dtrace_probe_is_enabled (struct gdbarch *gdbarch, gdbarch_dtrace_probe_is_enabled_ftype *dtrace_probe_is_enabled); 1381 1382/* Enable a DTrace is-enabled probe at ADDR. */ 1383 1384extern int gdbarch_dtrace_enable_probe_p (struct gdbarch *gdbarch); 1385 1386typedef void (gdbarch_dtrace_enable_probe_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); 1387extern void gdbarch_dtrace_enable_probe (struct gdbarch *gdbarch, CORE_ADDR addr); 1388extern void set_gdbarch_dtrace_enable_probe (struct gdbarch *gdbarch, gdbarch_dtrace_enable_probe_ftype *dtrace_enable_probe); 1389 1390/* Disable a DTrace is-enabled probe at ADDR. */ 1391 1392extern int gdbarch_dtrace_disable_probe_p (struct gdbarch *gdbarch); 1393 1394typedef void (gdbarch_dtrace_disable_probe_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); 1395extern void gdbarch_dtrace_disable_probe (struct gdbarch *gdbarch, CORE_ADDR addr); 1396extern void set_gdbarch_dtrace_disable_probe (struct gdbarch *gdbarch, gdbarch_dtrace_disable_probe_ftype *dtrace_disable_probe); 1397 1398/* True if the list of shared libraries is one and only for all 1399 processes, as opposed to a list of shared libraries per inferior. 1400 This usually means that all processes, although may or may not share 1401 an address space, will see the same set of symbols at the same 1402 addresses. */ 1403 1404extern int gdbarch_has_global_solist (struct gdbarch *gdbarch); 1405extern void set_gdbarch_has_global_solist (struct gdbarch *gdbarch, int has_global_solist); 1406 1407/* On some targets, even though each inferior has its own private 1408 address space, the debug interface takes care of making breakpoints 1409 visible to all address spaces automatically. For such cases, 1410 this property should be set to true. */ 1411 1412extern int gdbarch_has_global_breakpoints (struct gdbarch *gdbarch); 1413extern void set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch, int has_global_breakpoints); 1414 1415/* True if inferiors share an address space (e.g., uClinux). */ 1416 1417typedef int (gdbarch_has_shared_address_space_ftype) (struct gdbarch *gdbarch); 1418extern int gdbarch_has_shared_address_space (struct gdbarch *gdbarch); 1419extern void set_gdbarch_has_shared_address_space (struct gdbarch *gdbarch, gdbarch_has_shared_address_space_ftype *has_shared_address_space); 1420 1421/* True if a fast tracepoint can be set at an address. */ 1422 1423typedef int (gdbarch_fast_tracepoint_valid_at_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, std::string *msg); 1424extern int gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, std::string *msg); 1425extern void set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at); 1426 1427/* Guess register state based on tracepoint location. Used for tracepoints 1428 where no registers have been collected, but there's only one location, 1429 allowing us to guess the PC value, and perhaps some other registers. 1430 On entry, regcache has all registers marked as unavailable. */ 1431 1432typedef void (gdbarch_guess_tracepoint_registers_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr); 1433extern void gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr); 1434extern void set_gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, gdbarch_guess_tracepoint_registers_ftype *guess_tracepoint_registers); 1435 1436/* Return the "auto" target charset. */ 1437 1438typedef const char * (gdbarch_auto_charset_ftype) (void); 1439extern const char * gdbarch_auto_charset (struct gdbarch *gdbarch); 1440extern void set_gdbarch_auto_charset (struct gdbarch *gdbarch, gdbarch_auto_charset_ftype *auto_charset); 1441 1442/* Return the "auto" target wide charset. */ 1443 1444typedef const char * (gdbarch_auto_wide_charset_ftype) (void); 1445extern const char * gdbarch_auto_wide_charset (struct gdbarch *gdbarch); 1446extern void set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch, gdbarch_auto_wide_charset_ftype *auto_wide_charset); 1447 1448/* If non-empty, this is a file extension that will be opened in place 1449 of the file extension reported by the shared library list. 1450 1451 This is most useful for toolchains that use a post-linker tool, 1452 where the names of the files run on the target differ in extension 1453 compared to the names of the files GDB should load for debug info. */ 1454 1455extern const char * gdbarch_solib_symbols_extension (struct gdbarch *gdbarch); 1456extern void set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch, const char * solib_symbols_extension); 1457 1458/* If true, the target OS has DOS-based file system semantics. That 1459 is, absolute paths include a drive name, and the backslash is 1460 considered a directory separator. */ 1461 1462extern int gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch); 1463extern void set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch, int has_dos_based_file_system); 1464 1465/* Generate bytecodes to collect the return address in a frame. 1466 Since the bytecodes run on the target, possibly with GDB not even 1467 connected, the full unwinding machinery is not available, and 1468 typically this function will issue bytecodes for one or more likely 1469 places that the return address may be found. */ 1470 1471typedef void (gdbarch_gen_return_address_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope); 1472extern void gdbarch_gen_return_address (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope); 1473extern void set_gdbarch_gen_return_address (struct gdbarch *gdbarch, gdbarch_gen_return_address_ftype *gen_return_address); 1474 1475/* Implement the "info proc" command. */ 1476 1477extern int gdbarch_info_proc_p (struct gdbarch *gdbarch); 1478 1479typedef void (gdbarch_info_proc_ftype) (struct gdbarch *gdbarch, const char *args, enum info_proc_what what); 1480extern void gdbarch_info_proc (struct gdbarch *gdbarch, const char *args, enum info_proc_what what); 1481extern void set_gdbarch_info_proc (struct gdbarch *gdbarch, gdbarch_info_proc_ftype *info_proc); 1482 1483/* Implement the "info proc" command for core files. Noe that there 1484 are two "info_proc"-like methods on gdbarch -- one for core files, 1485 one for live targets. */ 1486 1487extern int gdbarch_core_info_proc_p (struct gdbarch *gdbarch); 1488 1489typedef void (gdbarch_core_info_proc_ftype) (struct gdbarch *gdbarch, const char *args, enum info_proc_what what); 1490extern void gdbarch_core_info_proc (struct gdbarch *gdbarch, const char *args, enum info_proc_what what); 1491extern void set_gdbarch_core_info_proc (struct gdbarch *gdbarch, gdbarch_core_info_proc_ftype *core_info_proc); 1492 1493/* Iterate over all objfiles in the order that makes the most sense 1494 for the architecture to make global symbol searches. 1495 1496 CB is a callback function where OBJFILE is the objfile to be searched, 1497 and CB_DATA a pointer to user-defined data (the same data that is passed 1498 when calling this gdbarch method). The iteration stops if this function 1499 returns nonzero. 1500 1501 CB_DATA is a pointer to some user-defined data to be passed to 1502 the callback. 1503 1504 If not NULL, CURRENT_OBJFILE corresponds to the objfile being 1505 inspected when the symbol search was requested. */ 1506 1507typedef 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); 1508extern 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); 1509extern 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); 1510 1511/* Ravenscar arch-dependent ops. */ 1512 1513extern struct ravenscar_arch_ops * gdbarch_ravenscar_ops (struct gdbarch *gdbarch); 1514extern void set_gdbarch_ravenscar_ops (struct gdbarch *gdbarch, struct ravenscar_arch_ops * ravenscar_ops); 1515 1516/* Return non-zero if the instruction at ADDR is a call; zero otherwise. */ 1517 1518typedef int (gdbarch_insn_is_call_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); 1519extern int gdbarch_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr); 1520extern void set_gdbarch_insn_is_call (struct gdbarch *gdbarch, gdbarch_insn_is_call_ftype *insn_is_call); 1521 1522/* Return non-zero if the instruction at ADDR is a return; zero otherwise. */ 1523 1524typedef int (gdbarch_insn_is_ret_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); 1525extern int gdbarch_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr); 1526extern void set_gdbarch_insn_is_ret (struct gdbarch *gdbarch, gdbarch_insn_is_ret_ftype *insn_is_ret); 1527 1528/* Return non-zero if the instruction at ADDR is a jump; zero otherwise. */ 1529 1530typedef int (gdbarch_insn_is_jump_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); 1531extern int gdbarch_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr); 1532extern void set_gdbarch_insn_is_jump (struct gdbarch *gdbarch, gdbarch_insn_is_jump_ftype *insn_is_jump); 1533 1534/* Return true if there's a program/permanent breakpoint planted in 1535 memory at ADDRESS, return false otherwise. */ 1536 1537typedef bool (gdbarch_program_breakpoint_here_p_ftype) (struct gdbarch *gdbarch, CORE_ADDR address); 1538extern bool gdbarch_program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address); 1539extern void set_gdbarch_program_breakpoint_here_p (struct gdbarch *gdbarch, gdbarch_program_breakpoint_here_p_ftype *program_breakpoint_here_p); 1540 1541/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR. 1542 Return 0 if *READPTR is already at the end of the buffer. 1543 Return -1 if there is insufficient buffer for a whole entry. 1544 Return 1 if an entry was read into *TYPEP and *VALP. */ 1545 1546extern int gdbarch_auxv_parse_p (struct gdbarch *gdbarch); 1547 1548typedef int (gdbarch_auxv_parse_ftype) (struct gdbarch *gdbarch, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp); 1549extern int gdbarch_auxv_parse (struct gdbarch *gdbarch, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp); 1550extern void set_gdbarch_auxv_parse (struct gdbarch *gdbarch, gdbarch_auxv_parse_ftype *auxv_parse); 1551 1552/* Print the description of a single auxv entry described by TYPE and VAL 1553 to FILE. */ 1554 1555typedef void (gdbarch_print_auxv_entry_ftype) (struct gdbarch *gdbarch, struct ui_file *file, CORE_ADDR type, CORE_ADDR val); 1556extern void gdbarch_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file, CORE_ADDR type, CORE_ADDR val); 1557extern void set_gdbarch_print_auxv_entry (struct gdbarch *gdbarch, gdbarch_print_auxv_entry_ftype *print_auxv_entry); 1558 1559/* Find the address range of the current inferior's vsyscall/vDSO, and 1560 write it to *RANGE. If the vsyscall's length can't be determined, a 1561 range with zero length is returned. Returns true if the vsyscall is 1562 found, false otherwise. */ 1563 1564typedef int (gdbarch_vsyscall_range_ftype) (struct gdbarch *gdbarch, struct mem_range *range); 1565extern int gdbarch_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range); 1566extern void set_gdbarch_vsyscall_range (struct gdbarch *gdbarch, gdbarch_vsyscall_range_ftype *vsyscall_range); 1567 1568/* Allocate SIZE bytes of PROT protected page aligned memory in inferior. 1569 PROT has GDB_MMAP_PROT_* bitmask format. 1570 Throw an error if it is not possible. Returned address is always valid. */ 1571 1572typedef CORE_ADDR (gdbarch_infcall_mmap_ftype) (CORE_ADDR size, unsigned prot); 1573extern CORE_ADDR gdbarch_infcall_mmap (struct gdbarch *gdbarch, CORE_ADDR size, unsigned prot); 1574extern void set_gdbarch_infcall_mmap (struct gdbarch *gdbarch, gdbarch_infcall_mmap_ftype *infcall_mmap); 1575 1576/* Deallocate SIZE bytes of memory at ADDR in inferior from gdbarch_infcall_mmap. 1577 Print a warning if it is not possible. */ 1578 1579typedef void (gdbarch_infcall_munmap_ftype) (CORE_ADDR addr, CORE_ADDR size); 1580extern void gdbarch_infcall_munmap (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR size); 1581extern void set_gdbarch_infcall_munmap (struct gdbarch *gdbarch, gdbarch_infcall_munmap_ftype *infcall_munmap); 1582 1583/* Return string (caller has to use xfree for it) with options for GCC 1584 to produce code for this target, typically "-m64", "-m32" or "-m31". 1585 These options are put before CU's DW_AT_producer compilation options so that 1586 they can override it. */ 1587 1588typedef std::string (gdbarch_gcc_target_options_ftype) (struct gdbarch *gdbarch); 1589extern std::string gdbarch_gcc_target_options (struct gdbarch *gdbarch); 1590extern void set_gdbarch_gcc_target_options (struct gdbarch *gdbarch, gdbarch_gcc_target_options_ftype *gcc_target_options); 1591 1592/* Return a regular expression that matches names used by this 1593 architecture in GNU configury triplets. The result is statically 1594 allocated and must not be freed. The default implementation simply 1595 returns the BFD architecture name, which is correct in nearly every 1596 case. */ 1597 1598typedef const char * (gdbarch_gnu_triplet_regexp_ftype) (struct gdbarch *gdbarch); 1599extern const char * gdbarch_gnu_triplet_regexp (struct gdbarch *gdbarch); 1600extern void set_gdbarch_gnu_triplet_regexp (struct gdbarch *gdbarch, gdbarch_gnu_triplet_regexp_ftype *gnu_triplet_regexp); 1601 1602/* Return the size in 8-bit bytes of an addressable memory unit on this 1603 architecture. This corresponds to the number of 8-bit bytes associated to 1604 each address in memory. */ 1605 1606typedef int (gdbarch_addressable_memory_unit_size_ftype) (struct gdbarch *gdbarch); 1607extern int gdbarch_addressable_memory_unit_size (struct gdbarch *gdbarch); 1608extern void set_gdbarch_addressable_memory_unit_size (struct gdbarch *gdbarch, gdbarch_addressable_memory_unit_size_ftype *addressable_memory_unit_size); 1609 1610/* Functions for allowing a target to modify its disassembler options. */ 1611 1612extern const char * gdbarch_disassembler_options_implicit (struct gdbarch *gdbarch); 1613extern void set_gdbarch_disassembler_options_implicit (struct gdbarch *gdbarch, const char * disassembler_options_implicit); 1614 1615extern char ** gdbarch_disassembler_options (struct gdbarch *gdbarch); 1616extern void set_gdbarch_disassembler_options (struct gdbarch *gdbarch, char ** disassembler_options); 1617 1618extern const disasm_options_and_args_t * gdbarch_valid_disassembler_options (struct gdbarch *gdbarch); 1619extern void set_gdbarch_valid_disassembler_options (struct gdbarch *gdbarch, const disasm_options_and_args_t * valid_disassembler_options); 1620 1621/* Type alignment override method. Return the architecture specific 1622 alignment required for TYPE. If there is no special handling 1623 required for TYPE then return the value 0, GDB will then apply the 1624 default rules as laid out in gdbtypes.c:type_align. */ 1625 1626typedef ULONGEST (gdbarch_type_align_ftype) (struct gdbarch *gdbarch, struct type *type); 1627extern ULONGEST gdbarch_type_align (struct gdbarch *gdbarch, struct type *type); 1628extern void set_gdbarch_type_align (struct gdbarch *gdbarch, gdbarch_type_align_ftype *type_align); 1629 1630/* Return a string containing any flags for the given PC in the given FRAME. */ 1631 1632typedef std::string (gdbarch_get_pc_address_flags_ftype) (frame_info *frame, CORE_ADDR pc); 1633extern std::string gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, frame_info *frame, CORE_ADDR pc); 1634extern void set_gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, gdbarch_get_pc_address_flags_ftype *get_pc_address_flags); 1635 1636/* Read core file mappings */ 1637 1638typedef void (gdbarch_read_core_file_mappings_ftype) (struct gdbarch *gdbarch, struct bfd *cbfd,gdb::function_view<void (ULONGEST count)> pre_loop_cb,gdb::function_view<void (int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs, const char *filename, const void *other)> loop_cb); 1639extern void gdbarch_read_core_file_mappings (struct gdbarch *gdbarch, struct bfd *cbfd,gdb::function_view<void (ULONGEST count)> pre_loop_cb,gdb::function_view<void (int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs, const char *filename, const void *other)> loop_cb); 1640extern void set_gdbarch_read_core_file_mappings (struct gdbarch *gdbarch, gdbarch_read_core_file_mappings_ftype *read_core_file_mappings); 1641 1642extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch); 1643 1644 1645/* Mechanism for co-ordinating the selection of a specific 1646 architecture. 1647 1648 GDB targets (*-tdep.c) can register an interest in a specific 1649 architecture. Other GDB components can register a need to maintain 1650 per-architecture data. 1651 1652 The mechanisms below ensures that there is only a loose connection 1653 between the set-architecture command and the various GDB 1654 components. Each component can independently register their need 1655 to maintain architecture specific data with gdbarch. 1656 1657 Pragmatics: 1658 1659 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It 1660 didn't scale. 1661 1662 The more traditional mega-struct containing architecture specific 1663 data for all the various GDB components was also considered. Since 1664 GDB is built from a variable number of (fairly independent) 1665 components it was determined that the global aproach was not 1666 applicable. */ 1667 1668 1669/* Register a new architectural family with GDB. 1670 1671 Register support for the specified ARCHITECTURE with GDB. When 1672 gdbarch determines that the specified architecture has been 1673 selected, the corresponding INIT function is called. 1674 1675 -- 1676 1677 The INIT function takes two parameters: INFO which contains the 1678 information available to gdbarch about the (possibly new) 1679 architecture; ARCHES which is a list of the previously created 1680 ``struct gdbarch'' for this architecture. 1681 1682 The INFO parameter is, as far as possible, be pre-initialized with 1683 information obtained from INFO.ABFD or the global defaults. 1684 1685 The ARCHES parameter is a linked list (sorted most recently used) 1686 of all the previously created architures for this architecture 1687 family. The (possibly NULL) ARCHES->gdbarch can used to access 1688 values from the previously selected architecture for this 1689 architecture family. 1690 1691 The INIT function shall return any of: NULL - indicating that it 1692 doesn't recognize the selected architecture; an existing ``struct 1693 gdbarch'' from the ARCHES list - indicating that the new 1694 architecture is just a synonym for an earlier architecture (see 1695 gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch'' 1696 - that describes the selected architecture (see gdbarch_alloc()). 1697 1698 The DUMP_TDEP function shall print out all target specific values. 1699 Care should be taken to ensure that the function works in both the 1700 multi-arch and non- multi-arch cases. */ 1701 1702struct gdbarch_list 1703{ 1704 struct gdbarch *gdbarch; 1705 struct gdbarch_list *next; 1706}; 1707 1708struct gdbarch_info 1709{ 1710 /* Use default: NULL (ZERO). */ 1711 const struct bfd_arch_info *bfd_arch_info; 1712 1713 /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */ 1714 enum bfd_endian byte_order; 1715 1716 enum bfd_endian byte_order_for_code; 1717 1718 /* Use default: NULL (ZERO). */ 1719 bfd *abfd; 1720 1721 /* Use default: NULL (ZERO). */ 1722 union 1723 { 1724 /* Architecture-specific information. The generic form for targets 1725 that have extra requirements. */ 1726 struct gdbarch_tdep_info *tdep_info; 1727 1728 /* Architecture-specific target description data. Numerous targets 1729 need only this, so give them an easy way to hold it. */ 1730 struct tdesc_arch_data *tdesc_data; 1731 1732 /* SPU file system ID. This is a single integer, so using the 1733 generic form would only complicate code. Other targets may 1734 reuse this member if suitable. */ 1735 int *id; 1736 }; 1737 1738 /* Use default: GDB_OSABI_UNINITIALIZED (-1). */ 1739 enum gdb_osabi osabi; 1740 1741 /* Use default: NULL (ZERO). */ 1742 const struct target_desc *target_desc; 1743}; 1744 1745typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches); 1746typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file); 1747 1748/* DEPRECATED - use gdbarch_register() */ 1749extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *); 1750 1751extern void gdbarch_register (enum bfd_architecture architecture, 1752 gdbarch_init_ftype *, 1753 gdbarch_dump_tdep_ftype *); 1754 1755 1756/* Return a freshly allocated, NULL terminated, array of the valid 1757 architecture names. Since architectures are registered during the 1758 _initialize phase this function only returns useful information 1759 once initialization has been completed. */ 1760 1761extern const char **gdbarch_printable_names (void); 1762 1763 1764/* Helper function. Search the list of ARCHES for a GDBARCH that 1765 matches the information provided by INFO. */ 1766 1767extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info); 1768 1769 1770/* Helper function. Create a preliminary ``struct gdbarch''. Perform 1771 basic initialization using values obtained from the INFO and TDEP 1772 parameters. set_gdbarch_*() functions are called to complete the 1773 initialization of the object. */ 1774 1775extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep); 1776 1777 1778/* Helper function. Free a partially-constructed ``struct gdbarch''. 1779 It is assumed that the caller freeds the ``struct 1780 gdbarch_tdep''. */ 1781 1782extern void gdbarch_free (struct gdbarch *); 1783 1784/* Get the obstack owned by ARCH. */ 1785 1786extern obstack *gdbarch_obstack (gdbarch *arch); 1787 1788/* Helper function. Allocate memory from the ``struct gdbarch'' 1789 obstack. The memory is freed when the corresponding architecture 1790 is also freed. */ 1791 1792#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) obstack_calloc<TYPE> (gdbarch_obstack ((GDBARCH)), (NR)) 1793 1794#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) obstack_zalloc<TYPE> (gdbarch_obstack ((GDBARCH))) 1795 1796/* Duplicate STRING, returning an equivalent string that's allocated on the 1797 obstack associated with GDBARCH. The string is freed when the corresponding 1798 architecture is also freed. */ 1799 1800extern char *gdbarch_obstack_strdup (struct gdbarch *arch, const char *string); 1801 1802/* Helper function. Force an update of the current architecture. 1803 1804 The actual architecture selected is determined by INFO, ``(gdb) set 1805 architecture'' et.al., the existing architecture and BFD's default 1806 architecture. INFO should be initialized to zero and then selected 1807 fields should be updated. 1808 1809 Returns non-zero if the update succeeds. */ 1810 1811extern int gdbarch_update_p (struct gdbarch_info info); 1812 1813 1814/* Helper function. Find an architecture matching info. 1815 1816 INFO should be initialized using gdbarch_info_init, relevant fields 1817 set, and then finished using gdbarch_info_fill. 1818 1819 Returns the corresponding architecture, or NULL if no matching 1820 architecture was found. */ 1821 1822extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info); 1823 1824 1825/* Helper function. Set the target gdbarch to "gdbarch". */ 1826 1827extern void set_target_gdbarch (struct gdbarch *gdbarch); 1828 1829 1830/* Register per-architecture data-pointer. 1831 1832 Reserve space for a per-architecture data-pointer. An identifier 1833 for the reserved data-pointer is returned. That identifer should 1834 be saved in a local static variable. 1835 1836 Memory for the per-architecture data shall be allocated using 1837 gdbarch_obstack_zalloc. That memory will be deleted when the 1838 corresponding architecture object is deleted. 1839 1840 When a previously created architecture is re-selected, the 1841 per-architecture data-pointer for that previous architecture is 1842 restored. INIT() is not re-called. 1843 1844 Multiple registrarants for any architecture are allowed (and 1845 strongly encouraged). */ 1846 1847struct gdbarch_data; 1848 1849typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack); 1850extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init); 1851typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch); 1852extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init); 1853 1854extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *); 1855 1856 1857/* Set the dynamic target-system-dependent parameters (architecture, 1858 byte-order, ...) using information found in the BFD. */ 1859 1860extern void set_gdbarch_from_file (bfd *); 1861 1862 1863/* Initialize the current architecture to the "first" one we find on 1864 our list. */ 1865 1866extern void initialize_current_architecture (void); 1867 1868/* gdbarch trace variable */ 1869extern unsigned int gdbarch_debug; 1870 1871extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file); 1872 1873/* Return the number of cooked registers (raw + pseudo) for ARCH. */ 1874 1875static inline int 1876gdbarch_num_cooked_regs (gdbarch *arch) 1877{ 1878 return gdbarch_num_regs (arch) + gdbarch_num_pseudo_regs (arch); 1879} 1880 1881#endif 1882