X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbarch.h;h=a239aa45966fcfc5aa34f50dc25ae9ddff210bcc;hb=18648a37491f7c0a459750048611bd2e83aa54bf;hp=0a62bfcb27b1e4b42b19887867b5cf433d9d876f;hpb=e7faf938594c703cb898154f1eed5278163eb2ec;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h index 0a62bfcb27..a239aa4596 100644 --- a/gdb/gdbarch.h +++ b/gdb/gdbarch.h @@ -2,8 +2,8 @@ /* Dynamic architecture support for GDB, the GNU debugger. - Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 - Free Software Foundation, Inc. + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, + 2007, 2008, 2009 Free Software Foundation, Inc. This file is part of GDB. @@ -30,7 +30,7 @@ If editing this file, please also run gdbarch.sh and merge any changes into that script. Conversely, when making sweeping changes to this file, modifying gdbarch.sh and using its output may prove - easier. */ + easier. */ #ifndef GDBARCH_H #define GDBARCH_H @@ -50,26 +50,57 @@ struct target_ops; struct obstack; struct bp_target_info; struct target_desc; +struct displaced_step_closure; +struct core_regset_section; +struct syscall; +struct agent_expr; +struct axs_value; +struct stap_parse_info; -extern struct gdbarch *current_gdbarch; +/* The architecture associated with the connection to the target. + + The architecture vector provides some information that is really + a property of the target: The layout of certain packets, for instance; + or the solib_ops vector. Etc. To differentiate architecture accesses + to per-target properties from per-thread/per-frame/per-objfile properties, + accesses to per-target properties should be made through target_gdbarch. + Eventually, when support for multiple targets is implemented in + GDB, this global should be made target-specific. */ +extern struct gdbarch *target_gdbarch; -/* The following are pre-initialized by GDBARCH. */ +/* Callback type for the 'iterate_over_objfiles_in_search_order' + gdbarch method. */ + +typedef int (iterate_over_objfiles_in_search_order_cb_ftype) + (struct objfile *objfile, void *cb_data); + + +/* The following are pre-initialized by GDBARCH. */ extern const struct bfd_arch_info * gdbarch_bfd_arch_info (struct gdbarch *gdbarch); -/* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */ +/* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */ extern int gdbarch_byte_order (struct gdbarch *gdbarch); -/* set_gdbarch_byte_order() - not applicable - pre-initialized. */ +/* set_gdbarch_byte_order() - not applicable - pre-initialized. */ + +extern int gdbarch_byte_order_for_code (struct gdbarch *gdbarch); +/* set_gdbarch_byte_order_for_code() - not applicable - pre-initialized. */ extern enum gdb_osabi gdbarch_osabi (struct gdbarch *gdbarch); -/* set_gdbarch_osabi() - not applicable - pre-initialized. */ +/* set_gdbarch_osabi() - not applicable - pre-initialized. */ extern const struct target_desc * gdbarch_target_desc (struct gdbarch *gdbarch); -/* set_gdbarch_target_desc() - not applicable - pre-initialized. */ +/* set_gdbarch_target_desc() - not applicable - pre-initialized. */ + + +/* The following are initialized by the target dependent code. */ +/* The bit byte-order has to do just with numbering of bits in debugging symbols + and such. Conceptually, it's quite separate from byte/word byte order. */ -/* The following are initialized by the target dependent code. */ +extern int gdbarch_bits_big_endian (struct gdbarch *gdbarch); +extern void set_gdbarch_bits_big_endian (struct gdbarch *gdbarch, int bits_big_endian); /* Number of bits in a char or unsigned char for the target machine. Just like CHAR_BIT in but describes the target machine. @@ -96,12 +127,24 @@ extern void set_gdbarch_long_bit (struct gdbarch *gdbarch, int long_bit); extern int gdbarch_long_long_bit (struct gdbarch *gdbarch); extern void set_gdbarch_long_long_bit (struct gdbarch *gdbarch, int long_long_bit); -/* The ABI default bit-size and format for "float", "double", and "long - double". These bit/format pairs should eventually be combined into - a single object. For the moment, just initialize them as a pair. +/* Alignment of a long long or unsigned long long for the target + machine. */ + +extern int gdbarch_long_long_align_bit (struct gdbarch *gdbarch); +extern void set_gdbarch_long_long_align_bit (struct gdbarch *gdbarch, int long_long_align_bit); + +/* The ABI default bit-size and format for "half", "float", "double", and + "long double". These bit/format pairs should eventually be combined + into a single object. For the moment, just initialize them as a pair. Each format describes both the big and little endian layouts (if useful). */ +extern int gdbarch_half_bit (struct gdbarch *gdbarch); +extern void set_gdbarch_half_bit (struct gdbarch *gdbarch, int half_bit); + +extern const struct floatformat ** gdbarch_half_format (struct gdbarch *gdbarch); +extern void set_gdbarch_half_format (struct gdbarch *gdbarch, const struct floatformat ** half_format); + extern int gdbarch_float_bit (struct gdbarch *gdbarch); extern void set_gdbarch_float_bit (struct gdbarch *gdbarch, int float_bit); @@ -126,8 +169,8 @@ extern void set_gdbarch_long_double_format (struct gdbarch *gdbarch, const struc / addr_bit will be set from it. If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably - also need to set gdbarch_pointer_to_address and gdbarch_address_to_pointer - as well. + also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and + gdbarch_address_to_pointer as well. ptr_bit is the size of a pointer on the target */ @@ -139,6 +182,23 @@ extern void set_gdbarch_ptr_bit (struct gdbarch *gdbarch, int ptr_bit); extern int gdbarch_addr_bit (struct gdbarch *gdbarch); extern void set_gdbarch_addr_bit (struct gdbarch *gdbarch, int addr_bit); +/* dwarf2_addr_size is the target address size as used in the Dwarf debug + info. For .debug_frame FDEs, this is supposed to be the target address + size from the associated CU header, and which is equivalent to the + DWARF2_ADDR_SIZE as defined by the target specific GCC back-end. + Unfortunately there is no good way to determine this value. Therefore + dwarf2_addr_size simply defaults to the target pointer size. + + dwarf2_addr_size is not used for .eh_frame FDEs, which are generally + defined using the target's pointer size so far. + + Note that dwarf2_addr_size only needs to be redefined by a target if the + GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size, + and if Dwarf versions < 4 need to be supported. */ + +extern int gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch); +extern void set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch, int dwarf2_addr_size); + /* One if `char' acts like `signed char', zero if `unsigned char'. */ extern int gdbarch_char_signed (struct gdbarch *gdbarch); @@ -166,10 +226,21 @@ extern void set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, gdbarch_ extern int gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch); -typedef void (gdbarch_pseudo_register_read_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf); -extern void gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf); +typedef enum register_status (gdbarch_pseudo_register_read_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf); +extern enum register_status gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf); extern void set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read); +/* Read a register into a new struct value. If the register is wholly + or partly unavailable, this should call mark_value_bytes_unavailable + as appropriate. If this is defined, then pseudo_register_read will + never be called. */ + +extern int gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch); + +typedef struct value * (gdbarch_pseudo_register_read_value_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum); +extern struct value * gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum); +extern void set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value); + extern int gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch); typedef void (gdbarch_pseudo_register_write_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf); @@ -187,6 +258,25 @@ extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs); extern int gdbarch_num_pseudo_regs (struct gdbarch *gdbarch); extern void set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, int num_pseudo_regs); +/* Assemble agent expression bytecode to collect pseudo-register REG. + Return -1 if something goes wrong, 0 otherwise. */ + +extern int gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch); + +typedef int (gdbarch_ax_pseudo_register_collect_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg); +extern int gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg); +extern void set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect); + +/* Assemble agent expression bytecode to push the value of pseudo-register + REG on the interpreter stack. + Return -1 if something goes wrong, 0 otherwise. */ + +extern int gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch); + +typedef int (gdbarch_ax_pseudo_register_push_stack_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg); +extern int gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg); +extern void set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack); + /* GDB's standard (or well known) register numbers. These can map onto a real register or a pseudo (computed) register or not be defined at all (-1). @@ -206,29 +296,25 @@ extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum); /* Convert stab register number (from `r' declaration) to a gdb REGNUM. */ -typedef int (gdbarch_stab_reg_to_regnum_ftype) (int stab_regnr); +typedef int (gdbarch_stab_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int stab_regnr); extern int gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr); extern void set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum); /* Provide a default mapping from a ecoff register number to a gdb REGNUM. */ -typedef int (gdbarch_ecoff_reg_to_regnum_ftype) (int ecoff_regnr); +typedef int (gdbarch_ecoff_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int ecoff_regnr); extern int gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr); extern void set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum); -/* Provide a default mapping from a DWARF register number to a gdb REGNUM. */ - -typedef int (gdbarch_dwarf_reg_to_regnum_ftype) (int dwarf_regnr); -extern int gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr); -extern void set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum); - /* Convert from an sdb register number to an internal gdb register number. */ -typedef int (gdbarch_sdb_reg_to_regnum_ftype) (int sdb_regnr); +typedef int (gdbarch_sdb_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int sdb_regnr); extern int gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr); extern void set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum); -typedef int (gdbarch_dwarf2_reg_to_regnum_ftype) (int dwarf2_regnr); +/* Provide a default mapping from a DWARF2 register number to a gdb REGNUM. */ + +typedef int (gdbarch_dwarf2_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int dwarf2_regnr); extern int gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr); extern void set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum); @@ -248,13 +334,13 @@ extern void set_gdbarch_register_type (struct gdbarch *gdbarch, gdbarch_register /* See gdbint.texinfo, and PUSH_DUMMY_CALL. */ -extern int gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch); +extern int gdbarch_dummy_id_p (struct gdbarch *gdbarch); -typedef struct frame_id (gdbarch_unwind_dummy_id_ftype) (struct gdbarch *gdbarch, struct frame_info *info); -extern struct frame_id gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info); -extern void set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, gdbarch_unwind_dummy_id_ftype *unwind_dummy_id); +typedef struct frame_id (gdbarch_dummy_id_ftype) (struct gdbarch *gdbarch, struct frame_info *this_frame); +extern struct frame_id gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame); +extern void set_gdbarch_dummy_id (struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id); -/* Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete +/* Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete deprecated_fp_regnum. */ extern int gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch); @@ -323,8 +409,8 @@ typedef int (gdbarch_convert_register_p_ftype) (struct gdbarch *gdbarch, int reg extern int gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type); extern void set_gdbarch_convert_register_p (struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype *convert_register_p); -typedef void (gdbarch_register_to_value_ftype) (struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf); -extern void gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf); +typedef int (gdbarch_register_to_value_ftype) (struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep); +extern int gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep); extern void set_gdbarch_register_to_value (struct gdbarch *gdbarch, gdbarch_register_to_value_ftype *register_to_value); typedef void (gdbarch_value_to_register_ftype) (struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf); @@ -340,11 +426,11 @@ typedef struct value * (gdbarch_value_from_register_ftype) (struct type *type, i extern struct value * gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame); extern void set_gdbarch_value_from_register (struct gdbarch *gdbarch, gdbarch_value_from_register_ftype *value_from_register); -typedef CORE_ADDR (gdbarch_pointer_to_address_ftype) (struct type *type, const gdb_byte *buf); +typedef CORE_ADDR (gdbarch_pointer_to_address_ftype) (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf); extern CORE_ADDR gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf); extern void set_gdbarch_pointer_to_address (struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address); -typedef void (gdbarch_address_to_pointer_ftype) (struct type *type, gdb_byte *buf, CORE_ADDR addr); +typedef void (gdbarch_address_to_pointer_ftype) (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr); extern void gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr); extern void set_gdbarch_address_to_pointer (struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer); @@ -354,20 +440,43 @@ typedef CORE_ADDR (gdbarch_integer_to_address_ftype) (struct gdbarch *gdbarch, s extern CORE_ADDR gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf); extern void set_gdbarch_integer_to_address (struct gdbarch *gdbarch, gdbarch_integer_to_address_ftype *integer_to_address); -/* It has been suggested that this, well actually its predecessor, - should take the type/value of the function to be called and not the - return type. This is left as an exercise for the reader. */ +/* Return the return-value convention that will be used by FUNCTION + to return a value of type VALTYPE. FUNCTION may be NULL in which + case the return convention is computed based only on VALTYPE. + + If READBUF is not NULL, extract the return value and save it in this buffer. + + If WRITEBUF is not NULL, it contains a return value which will be + stored into the appropriate register. This can be used when we want + to force the value returned by a function (see the "return" command + for instance). */ extern int gdbarch_return_value_p (struct gdbarch *gdbarch); -typedef enum return_value_convention (gdbarch_return_value_ftype) (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf); -extern enum return_value_convention gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf); +typedef enum return_value_convention (gdbarch_return_value_ftype) (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf); +extern enum return_value_convention gdbarch_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf); extern void set_gdbarch_return_value (struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value); -typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (CORE_ADDR ip); +/* Return true if the return value of function is stored in the first hidden + parameter. In theory, this feature should be language-dependent, specified + by language and its ABI, such as C++. Unfortunately, compiler may + implement it to a target-dependent feature. So that we need such hook here + to be aware of this in GDB. */ + +typedef int (gdbarch_return_in_first_hidden_param_p_ftype) (struct gdbarch *gdbarch, struct type *type); +extern int gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, struct type *type); +extern void set_gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, gdbarch_return_in_first_hidden_param_p_ftype *return_in_first_hidden_param_p); + +typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip); extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip); extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue); +extern int gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch); + +typedef CORE_ADDR (gdbarch_skip_main_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip); +extern CORE_ADDR gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip); +extern void set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype *skip_main_prologue); + typedef int (gdbarch_inner_than_ftype) (CORE_ADDR lhs, CORE_ADDR rhs); extern int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs); extern void set_gdbarch_inner_than (struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than); @@ -376,17 +485,25 @@ typedef const gdb_byte * (gdbarch_breakpoint_from_pc_ftype) (struct gdbarch *gdb extern const gdb_byte * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr); extern void set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc); +/* Return the adjusted address and kind to use for Z0/Z1 packets. + KIND is usually the memory length of the breakpoint, but may have a + different target-specific meaning. */ + +typedef void (gdbarch_remote_breakpoint_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr); +extern void gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr); +extern void set_gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_remote_breakpoint_from_pc_ftype *remote_breakpoint_from_pc); + extern int gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch); typedef CORE_ADDR (gdbarch_adjust_breakpoint_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR bpaddr); extern CORE_ADDR gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr); extern void set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address); -typedef int (gdbarch_memory_insert_breakpoint_ftype) (struct bp_target_info *bp_tgt); +typedef int (gdbarch_memory_insert_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt); extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt); extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint); -typedef int (gdbarch_memory_remove_breakpoint_ftype) (struct bp_target_info *bp_tgt); +typedef int (gdbarch_memory_remove_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt); extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt); extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint); @@ -470,14 +587,14 @@ extern void set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, gdb sort of generic thing to handle alignment or segmentation (it's possible it should be in TARGET_READ_PC instead). */ -typedef CORE_ADDR (gdbarch_addr_bits_remove_ftype) (CORE_ADDR addr); +typedef CORE_ADDR (gdbarch_addr_bits_remove_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); extern CORE_ADDR gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr); extern void set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype *addr_bits_remove); /* It is not at all clear why gdbarch_smash_text_address is not folded into gdbarch_addr_bits_remove. */ -typedef CORE_ADDR (gdbarch_smash_text_address_ftype) (CORE_ADDR addr); +typedef CORE_ADDR (gdbarch_smash_text_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr); extern CORE_ADDR gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr); extern void set_gdbarch_smash_text_address (struct gdbarch *gdbarch, gdbarch_smash_text_address_ftype *smash_text_address); @@ -521,7 +638,7 @@ typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (struct frame_info *frame extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc); extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code); -/* If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER +/* If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER evaluates non-zero, this is the address where the debugger will place a step-resume breakpoint to get us past the dynamic linker. */ @@ -531,8 +648,8 @@ extern void set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, gdbarch_sk /* Some systems also have trampoline code for returning from shared libs. */ -typedef int (gdbarch_in_solib_return_trampoline_ftype) (CORE_ADDR pc, char *name); -extern int gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name); +typedef int (gdbarch_in_solib_return_trampoline_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name); +extern int gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name); extern void set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline); /* A target might have problems with watchpoints as soon as the stack @@ -549,19 +666,6 @@ typedef int (gdbarch_in_function_epilogue_p_ftype) (struct gdbarch *gdbarch, COR extern int gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr); extern void set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p); -/* Given a vector of command-line arguments, return a newly allocated - string which, when passed to the create_inferior function, will be - parsed (on Unix systems, by the shell) to yield the same vector. - This function should call error() if the argument vector is not - representable for this target or if this target does not support - command-line arguments. - ARGC is the number of elements in the vector. - ARGV is an array of strings, one per argument. */ - -typedef char * (gdbarch_construct_inferior_arguments_ftype) (struct gdbarch *gdbarch, int argc, char **argv); -extern char * gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv); -extern void set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments); - typedef void (gdbarch_elf_make_msymbol_special_ftype) (asymbol *sym, struct minimal_symbol *msym); extern void gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym); extern void set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special); @@ -570,9 +674,6 @@ typedef void (gdbarch_coff_make_msymbol_special_ftype) (int val, struct minimal_ extern void gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym); extern void set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special); -extern const char * gdbarch_name_of_malloc (struct gdbarch *gdbarch); -extern void set_gdbarch_name_of_malloc (struct gdbarch *gdbarch, const char * name_of_malloc); - extern int gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch); extern void set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, int cannot_step_breakpoint); @@ -620,6 +721,27 @@ typedef const struct regset * (gdbarch_regset_from_core_section_ftype) (struct g extern const struct regset * gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size); extern void set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch, gdbarch_regset_from_core_section_ftype *regset_from_core_section); +/* Supported register notes in a core file. */ + +extern struct core_regset_section * gdbarch_core_regset_sections (struct gdbarch *gdbarch); +extern void set_gdbarch_core_regset_sections (struct gdbarch *gdbarch, struct core_regset_section * core_regset_sections); + +/* Create core file notes */ + +extern int gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch); + +typedef char * (gdbarch_make_corefile_notes_ftype) (struct gdbarch *gdbarch, bfd *obfd, int *note_size); +extern char * gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size); +extern void set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch, gdbarch_make_corefile_notes_ftype *make_corefile_notes); + +/* Find core file memory regions */ + +extern int gdbarch_find_memory_regions_p (struct gdbarch *gdbarch); + +typedef int (gdbarch_find_memory_regions_ftype) (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data); +extern int gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data); +extern void set_gdbarch_find_memory_regions (struct gdbarch *gdbarch, gdbarch_find_memory_regions_ftype *find_memory_regions); + /* Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from core file into buffer READBUF with length LEN. */ @@ -629,6 +751,21 @@ typedef LONGEST (gdbarch_core_xfer_shared_libraries_ftype) (struct gdbarch *gdba extern LONGEST gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len); extern void set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries); +/* How the core target converts a PTID from a core file to a string. */ + +extern int gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch); + +typedef char * (gdbarch_core_pid_to_str_ftype) (struct gdbarch *gdbarch, ptid_t ptid); +extern char * gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid); +extern void set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch, gdbarch_core_pid_to_str_ftype *core_pid_to_str); + +/* BFD target to use when generating a core file. */ + +extern int gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch); + +extern const char * gdbarch_gcore_bfd_target (struct gdbarch *gdbarch); +extern void set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch, const char * gcore_bfd_target); + /* If the elements of C++ vtables are in-place function descriptors rather than normal function pointers (which may point to code or a descriptor), set this to one. */ @@ -650,6 +787,127 @@ typedef void (gdbarch_skip_permanent_breakpoint_ftype) (struct regcache *regcach extern void gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache); extern void set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint); +/* The maximum length of an instruction on this architecture in bytes. */ + +extern int gdbarch_max_insn_length_p (struct gdbarch *gdbarch); + +extern ULONGEST gdbarch_max_insn_length (struct gdbarch *gdbarch); +extern void set_gdbarch_max_insn_length (struct gdbarch *gdbarch, ULONGEST max_insn_length); + +/* Copy the instruction at FROM to TO, and make any adjustments + necessary to single-step it at that address. + + REGS holds the state the thread's registers will have before + executing the copied instruction; the PC in REGS will refer to FROM, + not the copy at TO. The caller should update it to point at TO later. + + Return a pointer to data of the architecture's choice to be passed + to gdbarch_displaced_step_fixup. Or, return NULL to indicate that + the instruction's effects have been completely simulated, with the + resulting state written back to REGS. + + For a general explanation of displaced stepping and how GDB uses it, + see the comments in infrun.c. + + The TO area is only guaranteed to have space for + gdbarch_max_insn_length (arch) bytes, so this function must not + write more bytes than that to that area. + + If you do not provide this function, GDB assumes that the + architecture does not support displaced stepping. + + If your architecture doesn't need to adjust instructions before + single-stepping them, consider using simple_displaced_step_copy_insn + here. */ + +extern int gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch); + +typedef struct displaced_step_closure * (gdbarch_displaced_step_copy_insn_ftype) (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs); +extern struct displaced_step_closure * gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs); +extern void set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn); + +/* Return true if GDB should use hardware single-stepping to execute + the displaced instruction identified by CLOSURE. If false, + GDB will simply restart execution at the displaced instruction + location, and it is up to the target to ensure GDB will receive + control again (e.g. by placing a software breakpoint instruction + into the displaced instruction buffer). + + The default implementation returns false on all targets that + provide a gdbarch_software_single_step routine, and true otherwise. */ + +typedef int (gdbarch_displaced_step_hw_singlestep_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure); +extern int gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure); +extern void set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep); + +/* Fix up the state resulting from successfully single-stepping a + displaced instruction, to give the result we would have gotten from + stepping the instruction in its original location. + + REGS is the register state resulting from single-stepping the + displaced instruction. + + CLOSURE is the result from the matching call to + gdbarch_displaced_step_copy_insn. + + If you provide gdbarch_displaced_step_copy_insn.but not this + function, then GDB assumes that no fixup is needed after + single-stepping the instruction. + + For a general explanation of displaced stepping and how GDB uses it, + see the comments in infrun.c. */ + +extern int gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch); + +typedef void (gdbarch_displaced_step_fixup_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs); +extern void gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs); +extern void set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype *displaced_step_fixup); + +/* Free a closure returned by gdbarch_displaced_step_copy_insn. + + If you provide gdbarch_displaced_step_copy_insn, you must provide + this function as well. + + If your architecture uses closures that don't need to be freed, then + you can use simple_displaced_step_free_closure here. + + For a general explanation of displaced stepping and how GDB uses it, + see the comments in infrun.c. */ + +typedef void (gdbarch_displaced_step_free_closure_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure); +extern void gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, struct displaced_step_closure *closure); +extern void set_gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, gdbarch_displaced_step_free_closure_ftype *displaced_step_free_closure); + +/* Return the address of an appropriate place to put displaced + instructions while we step over them. There need only be one such + place, since we're only stepping one thread over a breakpoint at a + time. + + For a general explanation of displaced stepping and how GDB uses it, + see the comments in infrun.c. */ + +typedef CORE_ADDR (gdbarch_displaced_step_location_ftype) (struct gdbarch *gdbarch); +extern CORE_ADDR gdbarch_displaced_step_location (struct gdbarch *gdbarch); +extern void set_gdbarch_displaced_step_location (struct gdbarch *gdbarch, gdbarch_displaced_step_location_ftype *displaced_step_location); + +/* Relocate an instruction to execute at a different address. OLDLOC + is the address in the inferior memory where the instruction to + relocate is currently at. On input, TO points to the destination + where we want the instruction to be copied (and possibly adjusted) + to. On output, it points to one past the end of the resulting + instruction(s). The effect of executing the instruction at TO shall + be the same as if executing it at FROM. For example, call + instructions that implicitly push the return address on the stack + should be adjusted to return to the instruction after OLDLOC; + relative branches, and other PC-relative instructions need the + offset adjusted; etc. */ + +extern int gdbarch_relocate_instruction_p (struct gdbarch *gdbarch); + +typedef void (gdbarch_relocate_instruction_ftype) (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from); +extern void gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from); +extern void set_gdbarch_relocate_instruction (struct gdbarch *gdbarch, gdbarch_relocate_instruction_ftype *relocate_instruction); + /* Refresh overlay mapped state for section OSECT. */ extern int gdbarch_overlay_update_p (struct gdbarch *gdbarch); @@ -668,8 +926,8 @@ extern void set_gdbarch_core_read_description (struct gdbarch *gdbarch, gdbarch_ extern int gdbarch_static_transform_name_p (struct gdbarch *gdbarch); -typedef char * (gdbarch_static_transform_name_ftype) (char *name); -extern char * gdbarch_static_transform_name (struct gdbarch *gdbarch, char *name); +typedef const char * (gdbarch_static_transform_name_ftype) (const char *name); +extern const char * gdbarch_static_transform_name (struct gdbarch *gdbarch, const char *name); extern void set_gdbarch_static_transform_name (struct gdbarch *gdbarch, gdbarch_static_transform_name_ftype *static_transform_name); /* Set if the address in N_SO or N_FUN stabs may be zero. */ @@ -677,6 +935,283 @@ extern void set_gdbarch_static_transform_name (struct gdbarch *gdbarch, gdbarch_ extern int gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch); extern void set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch, int sofun_address_maybe_missing); +/* Parse the instruction at ADDR storing in the record execution log + the registers REGCACHE and memory ranges that will be affected when + the instruction executes, along with their current values. + Return -1 if something goes wrong, 0 otherwise. */ + +extern int gdbarch_process_record_p (struct gdbarch *gdbarch); + +typedef int (gdbarch_process_record_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr); +extern int gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr); +extern void set_gdbarch_process_record (struct gdbarch *gdbarch, gdbarch_process_record_ftype *process_record); + +/* Save process state after a signal. + Return -1 if something goes wrong, 0 otherwise. */ + +extern int gdbarch_process_record_signal_p (struct gdbarch *gdbarch); + +typedef int (gdbarch_process_record_signal_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal); +extern int gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal); +extern void set_gdbarch_process_record_signal (struct gdbarch *gdbarch, gdbarch_process_record_signal_ftype *process_record_signal); + +/* Signal translation: translate inferior's signal (target's) number + into GDB's representation. The implementation of this method must + be host independent. IOW, don't rely on symbols of the NAT_FILE + header (the nm-*.h files), the host header, or similar + headers. This is mainly used when cross-debugging core files --- + "Live" targets hide the translation behind the target interface + (target_wait, target_resume, etc.). */ + +extern int gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch); + +typedef enum gdb_signal (gdbarch_gdb_signal_from_target_ftype) (struct gdbarch *gdbarch, int signo); +extern enum gdb_signal gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, int signo); +extern void set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target); + +/* Extra signal info inspection. + + Return a type suitable to inspect extra signal information. */ + +extern int gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch); + +typedef struct type * (gdbarch_get_siginfo_type_ftype) (struct gdbarch *gdbarch); +extern struct type * gdbarch_get_siginfo_type (struct gdbarch *gdbarch); +extern void set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch, gdbarch_get_siginfo_type_ftype *get_siginfo_type); + +/* Record architecture-specific information from the symbol table. */ + +extern int gdbarch_record_special_symbol_p (struct gdbarch *gdbarch); + +typedef void (gdbarch_record_special_symbol_ftype) (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym); +extern void gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym); +extern void set_gdbarch_record_special_symbol (struct gdbarch *gdbarch, gdbarch_record_special_symbol_ftype *record_special_symbol); + +/* Function for the 'catch syscall' feature. + Get architecture-specific system calls information from registers. */ + +extern int gdbarch_get_syscall_number_p (struct gdbarch *gdbarch); + +typedef LONGEST (gdbarch_get_syscall_number_ftype) (struct gdbarch *gdbarch, ptid_t ptid); +extern LONGEST gdbarch_get_syscall_number (struct gdbarch *gdbarch, ptid_t ptid); +extern void set_gdbarch_get_syscall_number (struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype *get_syscall_number); + +/* SystemTap related fields and functions. + Prefix used to mark an integer constant on the architecture's assembly + For example, on x86 integer constants are written as: + + $10 ;; integer constant 10 + + in this case, this prefix would be the character `$'. */ + +extern const char * gdbarch_stap_integer_prefix (struct gdbarch *gdbarch); +extern void set_gdbarch_stap_integer_prefix (struct gdbarch *gdbarch, const char * stap_integer_prefix); + +/* Suffix used to mark an integer constant on the architecture's assembly. */ + +extern const char * gdbarch_stap_integer_suffix (struct gdbarch *gdbarch); +extern void set_gdbarch_stap_integer_suffix (struct gdbarch *gdbarch, const char * stap_integer_suffix); + +/* Prefix used to mark a register name on the architecture's assembly. + For example, on x86 the register name is written as: + + %eax ;; register eax + + in this case, this prefix would be the character `%'. */ + +extern const char * gdbarch_stap_register_prefix (struct gdbarch *gdbarch); +extern void set_gdbarch_stap_register_prefix (struct gdbarch *gdbarch, const char * stap_register_prefix); + +/* Suffix used to mark a register name on the architecture's assembly */ + +extern const char * gdbarch_stap_register_suffix (struct gdbarch *gdbarch); +extern void set_gdbarch_stap_register_suffix (struct gdbarch *gdbarch, const char * stap_register_suffix); + +/* Prefix used to mark a register indirection on the architecture's assembly. + For example, on x86 the register indirection is written as: + + (%eax) ;; indirecting eax + + in this case, this prefix would be the charater `('. + + Please note that we use the indirection prefix also for register + displacement, e.g., `4(%eax)' on x86. */ + +extern const char * gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch); +extern void set_gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch, const char * stap_register_indirection_prefix); + +/* Suffix used to mark a register indirection on the architecture's assembly. + For example, on x86 the register indirection is written as: + + (%eax) ;; indirecting eax + + in this case, this prefix would be the charater `)'. + + Please note that we use the indirection suffix also for register + displacement, e.g., `4(%eax)' on x86. */ + +extern const char * gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch); +extern void set_gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch, const char * stap_register_indirection_suffix); + +/* Prefix used to name a register using GDB's nomenclature. + + For example, on PPC a register is represented by a number in the assembly + language (e.g., `10' is the 10th general-purpose register). However, + inside GDB this same register has an `r' appended to its name, so the 10th + register would be represented as `r10' internally. */ + +extern const char * gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch); +extern void set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch, const char * stap_gdb_register_prefix); + +/* Suffix used to name a register using GDB's nomenclature. */ + +extern const char * gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch); +extern void set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch, const char * stap_gdb_register_suffix); + +/* Check if S is a single operand. + + Single operands can be: + - Literal integers, e.g. `$10' on x86 + - Register access, e.g. `%eax' on x86 + - Register indirection, e.g. `(%eax)' on x86 + - Register displacement, e.g. `4(%eax)' on x86 + + This function should check for these patterns on the string + and return 1 if some were found, or zero otherwise. Please try to match + as much info as you can from the string, i.e., if you have to match + something like `(%', do not match just the `('. */ + +extern int gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch); + +typedef int (gdbarch_stap_is_single_operand_ftype) (struct gdbarch *gdbarch, const char *s); +extern int gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s); +extern void set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand); + +/* Function used to handle a "special case" in the parser. + + A "special case" is considered to be an unknown token, i.e., a token + that the parser does not know how to parse. A good example of special + case would be ARM's register displacement syntax: + + [R0, #4] ;; displacing R0 by 4 + + Since the parser assumes that a register displacement is of the form: + + + + it means that it will not be able to recognize and parse this odd syntax. + Therefore, we should add a special case function that will handle this token. + + This function should generate the proper expression form of the expression + using GDB's internal expression mechanism (e.g., `write_exp_elt_opcode' + and so on). It should also return 1 if the parsing was successful, or zero + if the token was not recognized as a special token (in this case, returning + zero means that the special parser is deferring the parsing to the generic + parser), and should advance the buffer pointer (p->arg). */ + +extern int gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch); + +typedef int (gdbarch_stap_parse_special_token_ftype) (struct gdbarch *gdbarch, struct stap_parse_info *p); +extern int gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p); +extern void set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype *stap_parse_special_token); + +/* True if the list of shared libraries is one and only for all + processes, as opposed to a list of shared libraries per inferior. + This usually means that all processes, although may or may not share + an address space, will see the same set of symbols at the same + addresses. */ + +extern int gdbarch_has_global_solist (struct gdbarch *gdbarch); +extern void set_gdbarch_has_global_solist (struct gdbarch *gdbarch, int has_global_solist); + +/* On some targets, even though each inferior has its own private + address space, the debug interface takes care of making breakpoints + visible to all address spaces automatically. For such cases, + this property should be set to true. */ + +extern int gdbarch_has_global_breakpoints (struct gdbarch *gdbarch); +extern void set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch, int has_global_breakpoints); + +/* True if inferiors share an address space (e.g., uClinux). */ + +typedef int (gdbarch_has_shared_address_space_ftype) (struct gdbarch *gdbarch); +extern int gdbarch_has_shared_address_space (struct gdbarch *gdbarch); +extern void set_gdbarch_has_shared_address_space (struct gdbarch *gdbarch, gdbarch_has_shared_address_space_ftype *has_shared_address_space); + +/* True if a fast tracepoint can be set at an address. */ + +typedef int (gdbarch_fast_tracepoint_valid_at_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg); +extern int gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg); +extern void set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at); + +/* Return the "auto" target charset. */ + +typedef const char * (gdbarch_auto_charset_ftype) (void); +extern const char * gdbarch_auto_charset (struct gdbarch *gdbarch); +extern void set_gdbarch_auto_charset (struct gdbarch *gdbarch, gdbarch_auto_charset_ftype *auto_charset); + +/* Return the "auto" target wide charset. */ + +typedef const char * (gdbarch_auto_wide_charset_ftype) (void); +extern const char * gdbarch_auto_wide_charset (struct gdbarch *gdbarch); +extern void set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch, gdbarch_auto_wide_charset_ftype *auto_wide_charset); + +/* If non-empty, this is a file extension that will be opened in place + of the file extension reported by the shared library list. + + This is most useful for toolchains that use a post-linker tool, + where the names of the files run on the target differ in extension + compared to the names of the files GDB should load for debug info. */ + +extern const char * gdbarch_solib_symbols_extension (struct gdbarch *gdbarch); +extern void set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch, const char * solib_symbols_extension); + +/* If true, the target OS has DOS-based file system semantics. That + is, absolute paths include a drive name, and the backslash is + considered a directory separator. */ + +extern int gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch); +extern void set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch, int has_dos_based_file_system); + +/* Generate bytecodes to collect the return address in a frame. + Since the bytecodes run on the target, possibly with GDB not even + connected, the full unwinding machinery is not available, and + typically this function will issue bytecodes for one or more likely + places that the return address may be found. */ + +typedef void (gdbarch_gen_return_address_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope); +extern void gdbarch_gen_return_address (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope); +extern void set_gdbarch_gen_return_address (struct gdbarch *gdbarch, gdbarch_gen_return_address_ftype *gen_return_address); + +/* Implement the "info proc" command. */ + +extern int gdbarch_info_proc_p (struct gdbarch *gdbarch); + +typedef void (gdbarch_info_proc_ftype) (struct gdbarch *gdbarch, char *args, enum info_proc_what what); +extern void gdbarch_info_proc (struct gdbarch *gdbarch, char *args, enum info_proc_what what); +extern void set_gdbarch_info_proc (struct gdbarch *gdbarch, gdbarch_info_proc_ftype *info_proc); + +/* Iterate over all objfiles in the order that makes the most sense + for the architecture to make global symbol searches. + + CB is a callback function where OBJFILE is the objfile to be searched, + and CB_DATA a pointer to user-defined data (the same data that is passed + when calling this gdbarch method). The iteration stops if this function + returns nonzero. + + CB_DATA is a pointer to some user-defined data to be passed to + the callback. + + If not NULL, CURRENT_OBJFILE corresponds to the objfile being + inspected when the symbol search was requested. */ + +typedef void (gdbarch_iterate_over_objfiles_in_search_order_ftype) (struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile); +extern void gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile); +extern void set_gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch, gdbarch_iterate_over_objfiles_in_search_order_ftype *iterate_over_objfiles_in_search_order); + +/* Definition for an unknown syscall, used basically in error-cases. */ +#define UNKNOWN_SYSCALL (-1) + extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch); @@ -701,7 +1236,7 @@ extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch); data for all the various GDB components was also considered. Since GDB is built from a variable number of (fairly independent) components it was determined that the global aproach was not - applicable. */ + applicable. */ /* Register a new architectural family with GDB. @@ -724,8 +1259,7 @@ extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch); of all the previously created architures for this architecture family. The (possibly NULL) ARCHES->gdbarch can used to access values from the previously selected architecture for this - architecture family. The global ``current_gdbarch'' shall not be - used. + architecture family. The INIT function shall return any of: NULL - indicating that it doesn't recognize the selected architecture; an existing ``struct @@ -736,7 +1270,7 @@ extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch); The DUMP_TDEP function shall print out all target specific values. Care should be taken to ensure that the function works in both the - multi-arch and non- multi-arch cases. */ + multi-arch and non- multi-arch cases. */ struct gdbarch_list { @@ -746,16 +1280,18 @@ struct gdbarch_list struct gdbarch_info { - /* Use default: NULL (ZERO). */ + /* Use default: NULL (ZERO). */ const struct bfd_arch_info *bfd_arch_info; /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */ int byte_order; - /* Use default: NULL (ZERO). */ + int byte_order_for_code; + + /* Use default: NULL (ZERO). */ bfd *abfd; - /* Use default: NULL (ZERO). */ + /* Use default: NULL (ZERO). */ struct gdbarch_tdep_info *tdep_info; /* Use default: GDB_OSABI_UNINITIALIZED (-1). */ @@ -779,13 +1315,13 @@ extern void gdbarch_register (enum bfd_architecture architecture, /* Return a freshly allocated, NULL terminated, array of the valid architecture names. Since architectures are registered during the _initialize phase this function only returns useful information - once initialization has been completed. */ + once initialization has been completed. */ extern const char **gdbarch_printable_names (void); /* Helper function. Search the list of ARCHES for a GDBARCH that - matches the information provided by INFO. */ + matches the information provided by INFO. */ extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info); @@ -793,14 +1329,14 @@ extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *ar /* Helper function. Create a preliminary ``struct gdbarch''. Perform basic initialization using values obtained from the INFO and TDEP parameters. set_gdbarch_*() functions are called to complete the - initialization of the object. */ + initialization of the object. */ extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep); /* Helper function. Free a partially-constructed ``struct gdbarch''. It is assumed that the caller freeds the ``struct - gdbarch_tdep''. */ + gdbarch_tdep''. */ extern void gdbarch_free (struct gdbarch *); @@ -814,14 +1350,14 @@ extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size); #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE))) -/* Helper function. Force an update of the current architecture. +/* Helper function. Force an update of the current architecture. The actual architecture selected is determined by INFO, ``(gdb) set architecture'' et.al., the existing architecture and BFD's default architecture. INFO should be initialized to zero and then selected fields should be updated. - Returns non-zero if the update succeeds */ + Returns non-zero if the update succeeds. */ extern int gdbarch_update_p (struct gdbarch_info info); @@ -832,12 +1368,12 @@ extern int gdbarch_update_p (struct gdbarch_info info); set, and then finished using gdbarch_info_fill. Returns the corresponding architecture, or NULL if no matching - architecture was found. "current_gdbarch" is not updated. */ + architecture was found. */ extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info); -/* Helper function. Set the global "current_gdbarch" to "gdbarch". +/* Helper function. Set the global "target_gdbarch" to "gdbarch". FIXME: kettenis/20031124: Of the functions that follow, only gdbarch_from_bfd is supposed to survive. The others will @@ -845,7 +1381,7 @@ extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info); multi-arch. However, for now we're still stuck with the concept of a single active architecture. */ -extern void deprecated_current_gdbarch_select_hack (struct gdbarch *gdbarch); +extern void deprecated_target_gdbarch_select_hack (struct gdbarch *gdbarch); /* Register per-architecture data-pointer. @@ -879,7 +1415,7 @@ extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *); /* Set the dynamic target-system-dependent parameters (architecture, - byte-order, ...) using information found in the BFD */ + byte-order, ...) using information found in the BFD. */ extern void set_gdbarch_from_file (bfd *);