118 type=
"const struct bfd_arch_info *",
119 name=
"bfd_arch_info",
120 printer=
"gdbarch_bfd_arch_info (gdbarch)->printable_name",
124 type=
"enum bfd_endian",
129 type=
"enum bfd_endian",
130 name=
"byte_order_for_code",
134 type=
"enum gdb_osabi",
139 type=
"const struct target_desc *",
141 printer=
"host_address_to_string (gdbarch->target_desc)",
146Number of bits in a short or unsigned short for the target machine.
150 predefault=
"2*TARGET_CHAR_BIT",
156Number of bits in an int or unsigned int for the target machine.
160 predefault=
"4*TARGET_CHAR_BIT",
166Number of bits in a long or unsigned long for the target machine.
170 predefault=
"4*TARGET_CHAR_BIT",
176Number of bits in a long long or unsigned long long for the target
180 name=
"long_long_bit",
181 predefault=
"2*" + long_bit.predefault,
187The ABI default bit-size and format for "bfloat16", "half", "float", "double", and
188"long double". These bit/format pairs should eventually be combined
189into a single object. For the moment, just initialize them as a pair.
190Each format describes both the big
and little endian layouts (
if
195 predefault=
"2*TARGET_CHAR_BIT",
200 type=
"const struct floatformat **",
201 name=
"bfloat16_format",
202 postdefault=
"floatformats_bfloat16",
204 printer=
"pformat (gdbarch, gdbarch->bfloat16_format)",
210 predefault=
"2*TARGET_CHAR_BIT",
215 type=
"const struct floatformat **",
217 postdefault=
"floatformats_ieee_half",
219 printer=
"pformat (gdbarch, gdbarch->half_format)",
225 predefault=
"4*TARGET_CHAR_BIT",
230 type=
"const struct floatformat **",
232 postdefault=
"floatformats_ieee_single",
234 printer=
"pformat (gdbarch, gdbarch->float_format)",
240 predefault=
"8*TARGET_CHAR_BIT",
245 type=
"const struct floatformat **",
246 name=
"double_format",
247 postdefault=
"floatformats_ieee_double",
249 printer=
"pformat (gdbarch, gdbarch->double_format)",
254 name=
"long_double_bit",
255 predefault=
"8*TARGET_CHAR_BIT",
260 type=
"const struct floatformat **",
261 name=
"long_double_format",
262 postdefault=
"floatformats_ieee_double",
264 printer=
"pformat (gdbarch, gdbarch->long_double_format)",
269The ABI default bit-size for "wchar_t". wchar_t is a built-
in type
274 predefault=
"4*TARGET_CHAR_BIT",
280One if `wchar_t' is signed, zero if unsigned.
291Returns the floating-point format to be used for values of length LENGTH.
292NAME, if non-NULL, is the type name, which may be used to distinguish
293different target formats of the same length.
295 type=
"const struct floatformat **",
296 name=
"floatformat_for_type",
297 params=[(
"const char *",
"name"), (
"int",
"length")],
298 predefault=
"default_floatformat_for_type",
304For most targets, a pointer on the target and its representation as an
305address in GDB have the same size and "look the same". For such a
306target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
307/ addr_bit will be set
from it.
309If gdbarch_ptr_bit
and gdbarch_addr_bit are different, you
'll probably
310also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and
311gdbarch_address_to_pointer
as well.
313ptr_bit
is the size of a pointer on the target
317 predefault=int_bit.predefault,
323addr_bit is the size of a target address as represented in gdb
328 postdefault=
"gdbarch_ptr_bit (gdbarch)",
334dwarf2_addr_size is the target address size as used in the Dwarf debug
335info. For .debug_frame FDEs, this is supposed to be the target address
336size
from the associated CU header,
and which
is equivalent to the
337DWARF2_ADDR_SIZE
as defined by the target specific GCC back-end.
338Unfortunately there
is no good way to determine this value. Therefore
339dwarf2_addr_size simply defaults to the target pointer size.
341dwarf2_addr_size
is not used
for .eh_frame FDEs, which are generally
342defined using the target
's pointer size so far.
344Note that dwarf2_addr_size only needs to be redefined by a target if the
345GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size,
346and if Dwarf versions < 4 need to be supported.
349 name=
"dwarf2_addr_size",
351 postdefault=
"gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT",
357One if `char' acts like `signed char', zero if `unsigned char'.
369 params=[(
"readable_regcache *",
"regcache")],
377 params=[(
"struct regcache *",
"regcache"), (
"CORE_ADDR",
"val")],
384Function for getting target's idea of a frame pointer. FIXME: GDB's
385whole scheme for dealing
with "frames" and "frame pointers" needs a
389 name=
"virtual_frame_pointer",
392 (
"int *",
"frame_regnum"),
393 (
"LONGEST *",
"frame_offset"),
395 predefault=
"legacy_virtual_frame_pointer",
400 type=
"enum register_status",
401 name=
"pseudo_register_read",
403 (
"readable_regcache *",
"regcache"),
404 (
"int",
"cookednum"),
405 (
"gdb_byte *",
"buf"),
413Read a register into a new struct value. If the register is wholly
414or partly unavailable, this should call mark_value_bytes_unavailable
415as appropriate. If this
is defined, then pseudo_register_read will
418 type="struct value *",
419 name=
"pseudo_register_read_value",
420 params=[(
"readable_regcache *",
"regcache"), (
"int",
"cookednum")],
427 name=
"pseudo_register_write",
429 (
"struct regcache *",
"regcache"),
430 (
"int",
"cookednum"),
431 (
"const gdb_byte *",
"buf"),
446This macro gives the number of pseudo-registers that live in the
447register namespace but do not get fetched or stored on the target.
448These pseudo-registers may be aliases for other registers,
449combinations of other registers, or they may be computed by GDB.
452 name=
"num_pseudo_regs",
459Assemble agent expression bytecode to collect pseudo-register REG.
460Return -1 if something goes wrong, 0 otherwise.
463 name=
"ax_pseudo_register_collect",
464 params=[(
"struct agent_expr *",
"ax"), (
"int",
"reg")],
471Assemble agent expression bytecode to push the value of pseudo-register
472REG on the interpreter stack.
473Return -1 if something goes wrong, 0 otherwise.
476 name=
"ax_pseudo_register_push_stack",
477 params=[(
"struct agent_expr *",
"ax"), (
"int",
"reg")],
484Some architectures can display additional information for specific
486UIOUT is the output stream where the handler will place information.
489 name=
"report_signal_info",
490 params=[(
"struct ui_out *",
"uiout"), (
"enum gdb_signal",
"siggnal")],
497GDB's standard (or well known) register numbers. These can map onto
498a real register or a pseudo (computed) register
or not be defined at
500gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP.
531Convert stab register number (from `r' declaration) to a gdb REGNUM.
534 name=
"stab_reg_to_regnum",
535 params=[(
"int",
"stab_regnr")],
536 predefault=
"no_op_reg_to_regnum",
542Provide a default mapping from a ecoff register number to a gdb REGNUM.
545 name=
"ecoff_reg_to_regnum",
546 params=[(
"int",
"ecoff_regnr")],
547 predefault=
"no_op_reg_to_regnum",
553Convert from an sdb register number to an internal gdb register number.
556 name=
"sdb_reg_to_regnum",
557 params=[(
"int",
"sdb_regnr")],
558 predefault=
"no_op_reg_to_regnum",
564Provide a default mapping from a DWARF2 register number to a gdb REGNUM.
565Return -1 for bad REGNUM. Note: Several targets get this wrong.
568 name=
"dwarf2_reg_to_regnum",
569 params=[(
"int",
"dwarf2_regnr")],
570 predefault=
"no_op_reg_to_regnum",
576Return the name of register REGNR for the specified architecture.
577REGNR can be any value greater than, or equal to zero, and less than
578'gdbarch_num_cooked_regs (GDBARCH)'. If REGNR is not supported
for
579GDBARCH, then this function will
return an empty string, this function
580should never
return nullptr.
583 name=
"register_name",
584 params=[(
"int",
"regnr")],
585 param_checks=[
"regnr >= 0",
"regnr < gdbarch_num_cooked_regs (gdbarch)"],
586 result_checks=[
"result != nullptr"],
593Return the type of a register specified by the architecture. Only
594the register cache should call this function directly; others should
597 type="struct type *",
598 name=
"register_type",
599 params=[(
"int",
"reg_nr")],
605Generate a dummy frame_id for THIS_FRAME assuming that the frame is
606a dummy frame. A dummy frame is created before an inferior call,
607the frame_id returned here must match the frame_id that was built
608for the inferior call. Usually this means the returned frame_id
's
609stack address should match the address returned by
610gdbarch_push_dummy_call, and the returned frame_id
's code address
611should match the address at which the breakpoint was set in the dummy
614 type="struct frame_id",
616 params=[(
"frame_info_ptr",
"this_frame")],
617 predefault=
"default_dummy_id",
623Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
627 name=
"deprecated_fp_regnum",
634 name=
"push_dummy_call",
636 (
"struct value *",
"function"),
637 (
"struct regcache *",
"regcache"),
638 (
"CORE_ADDR",
"bp_addr"),
640 (
"struct value **",
"args"),
642 (
"function_call_return_method",
"return_method"),
643 (
"CORE_ADDR",
"struct_addr"),
650 type=
"enum call_dummy_location_type",
651 name=
"call_dummy_location",
652 predefault=
"AT_ENTRY_POINT",
658 name=
"push_dummy_code",
661 (
"CORE_ADDR",
"funaddr"),
662 (
"struct value **",
"args"),
664 (
"struct type *",
"value_type"),
665 (
"CORE_ADDR *",
"real_pc"),
666 (
"CORE_ADDR *",
"bp_addr"),
667 (
"struct regcache *",
"regcache"),
675Return true if the code of FRAME is writable.
678 name=
"code_of_frame_writable",
679 params=[(
"frame_info_ptr",
"frame")],
680 predefault=
"default_code_of_frame_writable",
686 name=
"print_registers_info",
688 (
"struct ui_file *",
"file"),
689 (
"frame_info_ptr",
"frame"),
693 predefault=
"default_print_registers_info",
699 name=
"print_float_info",
701 (
"struct ui_file *",
"file"),
702 (
"frame_info_ptr",
"frame"),
703 (
"const char *",
"args"),
705 predefault=
"default_print_float_info",
711 name=
"print_vector_info",
713 (
"struct ui_file *",
"file"),
714 (
"frame_info_ptr",
"frame"),
715 (
"const char *",
"args"),
723MAP a GDB RAW register number onto a simulator register number. See
724also include/...-sim.h.
727 name=
"register_sim_regno",
728 params=[(
"int",
"reg_nr")],
729 predefault=
"legacy_register_sim_regno",
735 name=
"cannot_fetch_register",
736 params=[(
"int",
"regnum")],
737 predefault=
"cannot_register_not",
743 name=
"cannot_store_register",
744 params=[(
"int",
"regnum")],
745 predefault=
"cannot_register_not",
751Determine the address where a longjmp will land and save this address
752in PC. Return nonzero on success.
754FRAME corresponds to the longjmp frame.
757 name=
"get_longjmp_target",
758 params=[(
"frame_info_ptr",
"frame"), (
"CORE_ADDR *",
"pc")],
765 name=
"believe_pcc_promotion",
771 name=
"convert_register_p",
772 params=[(
"int",
"regnum"), (
"struct type *",
"type")],
773 predefault=
"generic_convert_register_p",
779 name=
"register_to_value",
781 (
"frame_info_ptr",
"frame"),
783 (
"struct type *",
"type"),
784 (
"gdb_byte *",
"buf"),
785 (
"int *",
"optimizedp"),
786 (
"int *",
"unavailablep"),
793 name=
"value_to_register",
795 (
"frame_info_ptr",
"frame"),
797 (
"struct type *",
"type"),
798 (
"const gdb_byte *",
"buf"),
805Construct a value representing the contents of register REGNUM in
806frame FRAME_ID, interpreted as type TYPE. The routine needs to
807allocate and return a struct value
with all value attributes
808(but
not the value contents) filled
in.
810 type="struct value *",
811 name=
"value_from_register",
813 (
"struct type *",
"type"),
815 (
"struct frame_id",
"frame_id"),
817 predefault=
"default_value_from_register",
823 name=
"pointer_to_address",
824 params=[(
"struct type *",
"type"), (
"const gdb_byte *",
"buf")],
825 predefault=
"unsigned_pointer_to_address",
831 name=
"address_to_pointer",
832 params=[(
"struct type *",
"type"), (
"gdb_byte *",
"buf"), (
"CORE_ADDR",
"addr")],
833 predefault=
"unsigned_address_to_pointer",
839 name=
"integer_to_address",
840 params=[(
"struct type *",
"type"), (
"const gdb_byte *",
"buf")],
847Return the return-value convention that will be used by FUNCTION
848to return a value of type VALTYPE. FUNCTION may be NULL in which
849case the
return convention
is computed based only on VALTYPE.
851If READBUF
is not NULL, extract the
return value
and save it
in this buffer.
853If WRITEBUF
is not NULL, it contains a
return value which will be
854stored into the appropriate register. This can be used when we want
855to force the value returned by a function (see the
"return" command
858 type="enum return_value_convention",
861 (
"struct value *",
"function"),
862 (
"struct type *",
"valtype"),
863 (
"struct regcache *",
"regcache"),
864 (
"gdb_byte *",
"readbuf"),
865 (
"const gdb_byte *",
"writebuf"),
873Return the address at which the value being returned from
874the current function will be stored. This routine is only
875called
if the current function uses the the
"struct return
878May return 0 when unable to determine that address.
""",
880 name=
"get_return_buf_addr",
881 params=[(
"struct type *",
"val_type"), (
"frame_info_ptr",
"cur_frame")],
882 predefault=
"default_get_return_buf_addr",
888Return true if the return value of function is stored in the first hidden
889parameter. In theory, this feature should be language-dependent, specified
890by language and its ABI, such
as C++. Unfortunately, compiler may
891implement it to a target-dependent feature. So that we need such hook here
892to be aware of this
in GDB.
895 name=
"return_in_first_hidden_param_p",
896 params=[(
"struct type *",
"type")],
897 predefault=
"default_return_in_first_hidden_param_p",
903 name=
"skip_prologue",
904 params=[(
"CORE_ADDR",
"ip")],
911 name=
"skip_main_prologue",
912 params=[(
"CORE_ADDR",
"ip")],
919On some platforms, a single function may provide multiple entry points,
920e.g. one that is used for function-pointer calls and a different one
921that is used for direct function calls.
922In order to ensure that breakpoints set on the function will trigger
923no matter via which entry point the function is entered, a platform
924may provide the skip_entrypoint callback. It is called
with IP set
925to the main entry point of a function (
as determined by the symbol table),
926and should
return the address of the innermost entry point, where the
927actual breakpoint needs to be set. Note that skip_entrypoint
is used
928by GDB common code even when debugging optimized code, where skip_prologue
932 name=
"skip_entrypoint",
933 params=[(
"CORE_ADDR",
"ip")],
941 params=[(
"CORE_ADDR",
"lhs"), (
"CORE_ADDR",
"rhs")],
947 type=
"const gdb_byte *",
948 name=
"breakpoint_from_pc",
949 params=[(
"CORE_ADDR *",
"pcptr"), (
"int *",
"lenptr")],
950 predefault=
"default_breakpoint_from_pc",
956Return the breakpoint kind for this target based on *PCPTR.
959 name=
"breakpoint_kind_from_pc",
960 params=[(
"CORE_ADDR *",
"pcptr")],
967Return the software breakpoint from KIND. KIND can have target
968specific meaning like the Z0 kind parameter.
969SIZE is set to the software breakpoint
's length in memory.
971 type="const gdb_byte *",
972 name=
"sw_breakpoint_from_kind",
973 params=[(
"int",
"kind"), (
"int *",
"size")],
980Return the breakpoint kind for this target based on the current
981processor state (e.g. the current instruction mode on ARM) and the
982*PCPTR. In default, it is gdbarch->breakpoint_kind_from_pc.
985 name=
"breakpoint_kind_from_current_state",
986 params=[(
"struct regcache *",
"regcache"), (
"CORE_ADDR *",
"pcptr")],
987 predefault=
"default_breakpoint_kind_from_current_state",
993 name=
"adjust_breakpoint_address",
994 params=[(
"CORE_ADDR",
"bpaddr")],
1001 name=
"memory_insert_breakpoint",
1002 params=[(
"struct bp_target_info *",
"bp_tgt")],
1003 predefault=
"default_memory_insert_breakpoint",
1009 name=
"memory_remove_breakpoint",
1010 params=[(
"struct bp_target_info *",
"bp_tgt")],
1011 predefault=
"default_memory_remove_breakpoint",
1017 name=
"decr_pc_after_break",
1023A function can be addressed by either it's "pointer" (possibly a
1024descriptor address) or "entry point" (first executable instruction).
1025The method "convert_from_func_ptr_addr" converting the former to the
1026latter. gdbarch_deprecated_function_start_offset is being used to implement
1027a simplified subset of that functionality - the function
's address
1028corresponds to the "function pointer" and the function
's start
1029corresponds to the "function entry point" -
and hence
is redundant.
1032 name=
"deprecated_function_start_offset",
1038Return the remote protocol register number associated with this
1039register. Normally the identity mapping.
1042 name=
"remote_register_number",
1043 params=[(
"int",
"regno")],
1044 predefault=
"default_remote_register_number",
1050Fetch the target specific address used to represent a load module.
1053 name=
"fetch_tls_load_module_address",
1054 params=[(
"struct objfile *",
"objfile")],
1061Return the thread-local address at OFFSET in the thread-local
1062storage for the thread PTID and the shared library or executable
1063file given by LM_ADDR. If that block of thread-local storage hasn't
1064been allocated yet, this function may throw an error. LM_ADDR may
1065be zero for statically linked multithreaded inferiors.
1068 name=
"get_thread_local_address",
1069 params=[(
"ptid_t",
"ptid"), (
"CORE_ADDR",
"lm_addr"), (
"CORE_ADDR",
"offset")],
1076 name=
"frame_args_skip",
1083 params=[(
"frame_info_ptr",
"next_frame")],
1084 predefault=
"default_unwind_pc",
1091 params=[(
"frame_info_ptr",
"next_frame")],
1092 predefault=
"default_unwind_sp",
1098DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
1099frame-base. Enable frame-base before frame-unwind.
1102 name=
"frame_num_args",
1103 params=[(
"frame_info_ptr",
"frame")],
1111 params=[(
"CORE_ADDR",
"address")],
1118 name=
"stabs_argument_has_addr",
1119 params=[(
"struct type *",
"type")],
1120 predefault=
"default_stabs_argument_has_addr",
1126 name=
"frame_red_zone_size",
1132 name=
"convert_from_func_ptr_addr",
1133 params=[(
"CORE_ADDR",
"addr"), (
"struct target_ops *",
"targ")],
1134 predefault=
"convert_from_func_ptr_addr_identity",
1140On some machines there are bits in addresses which are not really
1141part of the address, but are used by the kernel, the hardware, etc.
1142for special purposes. gdbarch_addr_bits_remove takes out any such bits so
1143we get a "real" address such
as one would find
in a symbol table.
1144This
is used only
for addresses of instructions,
and even then I
'm
1145not sure it
's used in all contexts. It exists to deal with there
1146being a few stray bits in the PC which would mislead us,
not as some
1147sort of generic thing to handle alignment
or segmentation (it
's
1148possible it should be in TARGET_READ_PC instead).
1151 name=
"addr_bits_remove",
1152 params=[(
"CORE_ADDR",
"addr")],
1153 predefault=
"core_addr_identity",
1159On some architectures, not all bits of a pointer are significant.
1160On AArch64, for example, the top bits of a pointer may carry a "tag", which
1161can be ignored by the kernel and the hardware. The "tag" can be regarded
as
1162additional data associated
with the pointer, but it
is not part of the address.
1164Given a pointer
for the architecture, this hook removes all the
1165non-significant bits
and sign-extends things
as needed. It gets used to remove
1166non-address bits
from data pointers (
for example, removing the AArch64 MTE tag
1167bits
from a pointer)
and from code pointers (removing the AArch64 PAC signature
1168from a pointer containing the
return address).
1171 name=
"remove_non_address_bits",
1172 params=[(
"CORE_ADDR",
"pointer")],
1173 predefault=
"default_remove_non_address_bits",
1179Return a string representation of the memory tag TAG.
1182 name=
"memtag_to_string",
1183 params=[(
"struct value *",
"tag")],
1184 predefault=
"default_memtag_to_string",
1190Return true if ADDRESS contains a tag and false otherwise. ADDRESS
1191must be either a pointer or a reference type.
1194 name=
"tagged_address_p",
1195 params=[(
"struct value *",
"address")],
1196 predefault=
"default_tagged_address_p",
1202Return true if the tag from ADDRESS matches the memory tag for that
1203particular address. Return false otherwise.
1206 name=
"memtag_matches_p",
1207 params=[(
"struct value *",
"address")],
1208 predefault=
"default_memtag_matches_p",
1214Set the tags of type TAG_TYPE, for the memory address range
1215[ADDRESS, ADDRESS + LENGTH) to TAGS.
1216Return true if successful and false otherwise.
1221 (
"struct value *",
"address"),
1222 (
"size_t",
"length"),
1223 (
"const gdb::byte_vector &",
"tags"),
1224 (
"memtag_type",
"tag_type"),
1226 predefault=
"default_set_memtags",
1232Return the tag of type TAG_TYPE associated with the memory address ADDRESS,
1233assuming ADDRESS is tagged.
1235 type=
"struct value *",
1237 params=[(
"struct value *",
"address"), (
"memtag_type",
"tag_type")],
1238 predefault=
"default_get_memtag",
1244memtag_granule_size is the size of the allocation tag granule, for
1245architectures that support memory tagging.
1246This is 0 for architectures that do not support memory tagging.
1247For a non-zero value, this represents the number of bytes of memory per tag.
1250 name=
"memtag_granule_size",
1256FIXME/cagney/2001-01-18: This should be split in two. A target method that
1257indicates if the target needs software single step. An ISA method to
1260FIXME/cagney/2001-01-18: The logic
is backwards. It should be asking
if the
1261target can single step. If
not, then implement single step using breakpoints.
1263Return a vector of addresses on which the software single step
1264breakpoints should be inserted. NULL means software single step
is
1266Multiple breakpoints may be inserted
for some instructions such
as
1267conditional branch. However, each implementation must always evaluate
1268the condition
and only put the breakpoint at the branch destination
if
1269the condition
is true, so that we ensure forward progress when stepping
1270past a conditional branch to self.
1272 type="std::vector<CORE_ADDR>",
1273 name=
"software_single_step",
1274 params=[(
"struct regcache *",
"regcache")],
1281Return non-zero if the processor is executing a delay slot and a
1282further single-step is needed before the instruction finishes.
1285 name=
"single_step_through_delay",
1286 params=[(
"frame_info_ptr",
"frame")],
1293FIXME: cagney/2003-08-28: Need to find a better way of selecting the
1294disassembler. Perhaps objdump can handle it?
1298 params=[(
"bfd_vma",
"vma"), (
"struct disassemble_info *",
"info")],
1299 predefault=
"default_print_insn",
1305 name=
"skip_trampoline_code",
1306 params=[(
"frame_info_ptr",
"frame"), (
"CORE_ADDR",
"pc")],
1307 predefault=
"generic_skip_trampoline_code",
1312 comment=
"Vtable of solib operations functions.",
1313 type=
"const struct target_so_ops *",
1315 postdefault=
"&solib_target_so_ops",
1316 printer=
"host_address_to_string (gdbarch->so_ops)",
1321If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER
1322evaluates non-zero, this is the address where the debugger will place
1323a step-resume breakpoint to get us past the dynamic linker.
1326 name=
"skip_solib_resolver",
1327 params=[(
"CORE_ADDR",
"pc")],
1328 predefault=
"generic_skip_solib_resolver",
1334Some systems also have trampoline code for returning from shared libs.
1337 name=
"in_solib_return_trampoline",
1338 params=[(
"CORE_ADDR",
"pc"), (
"const char *",
"name")],
1339 predefault=
"generic_in_solib_return_trampoline",
1345Return true if PC lies inside an indirect branch thunk.
1348 name=
"in_indirect_branch_thunk",
1349 params=[(
"CORE_ADDR",
"pc")],
1350 predefault=
"default_in_indirect_branch_thunk",
1356A target might have problems with watchpoints as soon as the stack
1357frame of the current function has been destroyed. This mostly happens
1358as the first action
in a function
's epilogue. stack_frame_destroyed_p()
1359is defined to
return a non-zero value
if either the given addr
is one
1360instruction after the stack destroying instruction up to the trailing
1361return instruction
or if we can figure out that the stack frame has
1362already been invalidated regardless of the value of addr. Targets
1363which don
't suffer from that problem could just let this functionality
1367 name=
"stack_frame_destroyed_p",
1368 params=[(
"CORE_ADDR",
"addr")],
1369 predefault=
"generic_stack_frame_destroyed_p",
1375Process an ELF symbol in the minimal symbol table in a backend-specific
1376way. Normally this hook is supposed to do nothing, however
if required,
1377then this hook can be used to apply tranformations to symbols that are
1378considered special
in some way. For example the MIPS backend uses it
1379to interpret `st_other
' information to mark compressed code symbols so
1380that they can be treated in the appropriate manner
in the processing of
1381the main symbol table
and DWARF-2 records.
1384 name=
"elf_make_msymbol_special",
1385 params=[(
"asymbol *",
"sym"), (
"struct minimal_symbol *",
"msym")],
1392 name=
"coff_make_msymbol_special",
1393 params=[(
"int",
"val"), (
"struct minimal_symbol *",
"msym")],
1394 predefault=
"default_coff_make_msymbol_special",
1400Process a symbol in the main symbol table in a backend-specific way.
1401Normally this hook is supposed to do nothing, however if required,
1402then this hook can be used to apply tranformations to symbols that
1403are considered special in some way. This is currently used by the
1404MIPS backend to make sure compressed code symbols have the ISA bit
1405set. This
in turn
is needed
for symbol values seen
in GDB to match
1406the values used at the runtime by the program itself,
for function
1407and label references.
1410 name=
"make_symbol_special",
1411 params=[(
"struct symbol *",
"sym"), (
"struct objfile *",
"objfile")],
1412 predefault=
"default_make_symbol_special",
1418Adjust the address retrieved from a DWARF-2 record other than a line
1419entry in a backend-specific way. Normally this hook is supposed to
1420return the address passed unchanged, however
if that
is incorrect
for
1421any reason, then this hook can be used to fix the address up
in the
1422required manner. This
is currently used by the MIPS backend to make
1423sure addresses
in FDE, range records, etc. referring to compressed
1424code have the ISA bit set, matching line information
and the symbol
1428 name=
"adjust_dwarf2_addr",
1429 params=[(
"CORE_ADDR",
"pc")],
1430 predefault=
"default_adjust_dwarf2_addr",
1436Adjust the address updated by a line entry in a backend-specific way.
1437Normally this hook is supposed to return the address passed unchanged,
1438however in the case of inconsistencies in these records, this hook can
1439be used to fix them up in the required manner. This is currently used
1440by the MIPS backend to make sure all line addresses
in compressed code
1441are presented
with the ISA bit set, which
is not always the case. This
1442in turn ensures breakpoint addresses are correctly matched against the
1446 name=
"adjust_dwarf2_line",
1447 params=[(
"CORE_ADDR",
"addr"), (
"int",
"rel")],
1448 predefault=
"default_adjust_dwarf2_line",
1454 name=
"cannot_step_breakpoint",
1461See comment in target.h about continuable, steppable and
1462non-steppable watchpoints.
1465 name=
"have_nonsteppable_watchpoint",
1471 type=
"type_instance_flags",
1472 name=
"address_class_type_flags",
1473 params=[(
"int",
"byte_size"), (
"int",
"dwarf2_addr_class")],
1479 type=
"const char *",
1480 name=
"address_class_type_flags_to_name",
1481 params=[(
"type_instance_flags",
"type_flags")],
1488Execute vendor-specific DWARF Call Frame Instruction. OP is the instruction.
1489FS are passed
from the generic execute_cfa_program function.
1492 name=
"execute_dwarf_cfa_vendor_op",
1493 params=[(
"gdb_byte",
"op"), (
"struct dwarf2_frame_state *",
"fs")],
1494 predefault=
"default_execute_dwarf_cfa_vendor_op",
1500Return the appropriate type_flags for the supplied address class.
1501This function should return true if the address class was recognized and
1502type_flags was set, false otherwise.
1505 name=
"address_class_name_to_type_flags",
1506 params=[(
"const char *",
"name"), (
"type_instance_flags *",
"type_flags_ptr")],
1513Is a register in a group
1516 name=
"register_reggroup_p",
1517 params=[(
"int",
"regnum"), (
"const struct reggroup *",
"reggroup")],
1518 predefault=
"default_register_reggroup_p",
1524Fetch the pointer to the ith function argument.
1527 name=
"fetch_pointer_argument",
1529 (
"frame_info_ptr",
"frame"),
1531 (
"struct type *",
"type"),
1539Iterate over all supported register notes in a core file. For each
1540supported register note section, the iterator must call CB and pass
1541CB_DATA unchanged. If REGCACHE
is not NULL, the iterator can limit
1542the supported register note sections based on the current register
1543values. Otherwise it should enumerate all supported register note
1547 name=
"iterate_over_regset_sections",
1549 (
"iterate_over_regset_sections_cb *",
"cb"),
1550 (
"void *",
"cb_data"),
1551 (
"const struct regcache *",
"regcache"),
1559Create core file notes
1561 type=
"gdb::unique_xmalloc_ptr<char>",
1562 name=
"make_corefile_notes",
1563 params=[(
"bfd *",
"obfd"), (
"int *",
"note_size")],
1570Find core file memory regions
1573 name=
"find_memory_regions",
1574 params=[(
"find_memory_region_ftype",
"func"), (
"void *",
"data")],
1581Given a bfd OBFD, segment ADDRESS and SIZE, create a memory tag section to be dumped to a core file
1584 name=
"create_memtag_section",
1585 params=[(
"bfd *",
"obfd"), (
"CORE_ADDR",
"address"), (
"size_t",
"size")],
1592Given a memory tag section OSEC, fill OSEC's contents with the appropriate tag data
1595 name=
"fill_memtag_section",
1596 params=[(
"asection *",
"osec")],
1603Decode a memory tag SECTION and return the tags of type TYPE contained in
1604the memory range [ADDRESS, ADDRESS + LENGTH).
1605If no tags were found, return an empty vector.
1607 type=
"gdb::byte_vector",
1608 name=
"decode_memtag_section",
1610 (
"bfd_section *",
"section"),
1612 (
"CORE_ADDR",
"address"),
1613 (
"size_t",
"length"),
1621Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
1622core file into buffer READBUF with length LEN. Return the number of bytes read
1623(zero indicates failure).
1624failed, otherwise, return the red length of READBUF.
1627 name=
"core_xfer_shared_libraries",
1628 params=[(
"gdb_byte *",
"readbuf"), (
"ULONGEST",
"offset"), (
"ULONGEST",
"len")],
1635Read offset OFFSET of TARGET_OBJECT_LIBRARIES_AIX formatted shared
1636libraries list from core file into buffer READBUF with length LEN.
1637Return the number of bytes read (zero indicates failure).
1640 name=
"core_xfer_shared_libraries_aix",
1641 params=[(
"gdb_byte *",
"readbuf"), (
"ULONGEST",
"offset"), (
"ULONGEST",
"len")],
1648How the core target converts a PTID from a core file to a string.
1651 name=
"core_pid_to_str",
1652 params=[(
"ptid_t",
"ptid")],
1659How the core target extracts the name of a thread from a core file.
1661 type=
"const char *",
1662 name=
"core_thread_name",
1663 params=[(
"struct thread_info *",
"thr")],
1670Read offset OFFSET of TARGET_OBJECT_SIGNAL_INFO signal information
1671from core file into buffer READBUF with length LEN. Return the number
1672of bytes read (zero indicates EOF, a negative value indicates failure).
1675 name=
"core_xfer_siginfo",
1676 params=[(
"gdb_byte *",
"readbuf"), (
"ULONGEST",
"offset"), (
"ULONGEST",
"len")],
1683BFD target to use when generating a core file.
1685 type=
"const char *",
1686 name=
"gcore_bfd_target",
1690 printer=
"pstring (gdbarch->gcore_bfd_target)",
1695If the elements of C++ vtables are in-place function descriptors rather
1696than normal function pointers (which may point to code or a descriptor),
1700 name=
"vtable_function_descriptors",
1707Set if the least significant bit of the delta is used instead of the least
1708significant bit of the pfn for pointers to virtual member functions.
1711 name=
"vbit_in_delta",
1718Advance PC to next instruction in order to skip a permanent breakpoint.
1721 name=
"skip_permanent_breakpoint",
1722 params=[(
"struct regcache *",
"regcache")],
1723 predefault=
"default_skip_permanent_breakpoint",
1729The maximum length of an instruction on this architecture in bytes.
1732 name=
"max_insn_length",
1740Copy the instruction at FROM to TO, and make any adjustments
1741necessary to single-step it at that address.
1743REGS holds the state the thread's registers will have before
1744executing the copied instruction; the PC in REGS will refer to FROM,
1745not the copy at TO. The caller should update it to point at TO later.
1747Return a pointer to data of the architecture's choice to be passed
1748to gdbarch_displaced_step_fixup.
1750For a general explanation of displaced stepping and how GDB uses it,
1751see the comments
in infrun.c.
1753The TO area
is only guaranteed to have space
for
1754gdbarch_max_insn_length (arch) bytes, so this function must
not
1755write more bytes than that to that area.
1757If you do
not provide this function, GDB assumes that the
1758architecture does
not support displaced stepping.
1760If the instruction cannot execute out of line,
return NULL. The
1761core falls back to stepping past the instruction
in-line instead
in
1764 type="displaced_step_copy_insn_closure_up",
1765 name=
"displaced_step_copy_insn",
1766 params=[(
"CORE_ADDR",
"from"), (
"CORE_ADDR",
"to"), (
"struct regcache *",
"regs")],
1773Return true if GDB should use hardware single-stepping to execute a displaced
1774step instruction. If false, GDB will simply restart execution at the
1775displaced instruction location, and it
is up to the target to ensure GDB will
1776receive control again (e.g. by placing a software breakpoint instruction into
1777the displaced instruction buffer).
1779The default implementation returns false on all targets that provide a
1780gdbarch_software_single_step routine,
and true otherwise.
1783 name=
"displaced_step_hw_singlestep",
1785 predefault=
"default_displaced_step_hw_singlestep",
1791Fix up the state resulting from successfully single-stepping a
1792displaced instruction, to give the result we would have gotten from
1793stepping the instruction in its original location.
1795REGS is the register state resulting from single-stepping the
1796displaced instruction.
1798CLOSURE is the result from the matching call to
1799gdbarch_displaced_step_copy_insn.
1801If you provide gdbarch_displaced_step_copy_insn.but not this
1802function, then GDB assumes that no fixup is needed after
1803single-stepping the instruction.
1805For a general explanation of displaced stepping and how GDB uses it,
1806see the comments in infrun.c.
1809 name=
"displaced_step_fixup",
1811 (
"struct displaced_step_copy_insn_closure *",
"closure"),
1812 (
"CORE_ADDR",
"from"),
1813 (
"CORE_ADDR",
"to"),
1814 (
"struct regcache *",
"regs"),
1823Prepare THREAD for it to displaced step the instruction at its current PC.
1825Throw an exception if any unexpected error happens.
1827 type=
"displaced_step_prepare_status",
1828 name=
"displaced_step_prepare",
1829 params=[(
"thread_info *",
"thread"), (
"CORE_ADDR &",
"displaced_pc")],
1836Clean up after a displaced step of THREAD.
1838 type=
"displaced_step_finish_status",
1839 name=
"displaced_step_finish",
1840 params=[(
"thread_info *",
"thread"), (
"gdb_signal",
"sig")],
1842 invalid=
"(! gdbarch->displaced_step_finish) != (! gdbarch->displaced_step_prepare)",
1847Return the closure associated to the displaced step buffer that is at ADDR.
1849 type=
"const displaced_step_copy_insn_closure *",
1850 name=
"displaced_step_copy_insn_closure_by_addr",
1851 params=[(
"inferior *",
"inf"), (
"CORE_ADDR",
"addr")],
1858PARENT_INF has forked and CHILD_PTID is the ptid of the child. Restore the
1859contents of all displaced step buffers in the child
's address space.
1862 name=
"displaced_step_restore_all_in_ptid",
1863 params=[(
"inferior *",
"parent_inf"), (
"ptid_t",
"child_ptid")],
1869Relocate an instruction to execute at a different address. OLDLOC
1870is the address
in the inferior memory where the instruction to
1871relocate
is currently at. On input, TO points to the destination
1872where we want the instruction to be copied (
and possibly adjusted)
1873to. On output, it points to one past the end of the resulting
1874instruction(s). The effect of executing the instruction at TO shall
1875be the same
as if executing it at FROM. For example, call
1876instructions that implicitly push the
return address on the stack
1877should be adjusted to
return to the instruction after OLDLOC;
1878relative branches,
and other PC-relative instructions need the
1879offset adjusted; etc.
1882 name=
"relocate_instruction",
1883 params=[(
"CORE_ADDR *",
"to"), (
"CORE_ADDR",
"from")],
1891Refresh overlay mapped state for section OSECT.
1894 name=
"overlay_update",
1895 params=[(
"struct obj_section *",
"osect")],
1901 type=
"const struct target_desc *",
1902 name=
"core_read_description",
1903 params=[(
"struct target_ops *",
"target"), (
"bfd *",
"abfd")],
1910Set if the address in N_SO or N_FUN stabs may be zero.
1913 name=
"sofun_address_maybe_missing",
1920Parse the instruction at ADDR storing in the record execution log
1921the registers REGCACHE and memory ranges that will be affected when
1922the instruction executes, along with their current values.
1923Return -1 if something goes wrong, 0 otherwise.
1926 name=
"process_record",
1927 params=[(
"struct regcache *",
"regcache"), (
"CORE_ADDR",
"addr")],
1934Save process state after a signal.
1935Return -1 if something goes wrong, 0 otherwise.
1938 name=
"process_record_signal",
1939 params=[(
"struct regcache *",
"regcache"), (
"enum gdb_signal",
"signal")],
1946Signal translation: translate inferior's signal (target's) number
1947into GDB's representation. The implementation of this method must
1948be host independent. IOW, don't rely on symbols of the NAT_FILE
1949header (the nm-*.h files), the host <signal.h> header, or similar
1950headers. This
is mainly used when cross-debugging core files ---
1951"Live" targets hide the translation behind the target interface
1952(target_wait, target_resume, etc.).
1954 type="enum gdb_signal",
1955 name=
"gdb_signal_from_target",
1956 params=[(
"int",
"signo")],
1963Signal translation: translate the GDB's internal signal number into
1964the inferior's signal (target's) representation. The implementation
1965of this method must be host independent. IOW, don't rely on symbols
1966of the NAT_FILE header (the nm-*.h files), the host <signal.h>
1967header, or similar headers.
1968Return the target signal number
if found,
or -1
if the GDB internal
1969signal number
is invalid.
1972 name=
"gdb_signal_to_target",
1973 params=[(
"enum gdb_signal",
"signal")],
1980Extra signal info inspection.
1982Return a type suitable to inspect extra signal information.
1984 type=
"struct type *",
1985 name=
"get_siginfo_type",
1993Record architecture-specific information from the symbol table.
1996 name=
"record_special_symbol",
1997 params=[(
"struct objfile *",
"objfile"), (
"asymbol *",
"sym")],
2004Function for the 'catch syscall' feature.
2005Get architecture-specific system calls information from registers.
2008 name=
"get_syscall_number",
2009 params=[(
"thread_info *",
"thread")],
2016The filename of the XML syscall for this architecture.
2018 type=
"const char *",
2019 name=
"xml_syscall_file",
2022 printer=
"pstring (gdbarch->xml_syscall_file)",
2027Information about system calls from this architecture
2029 type=
"struct syscalls_info *",
2030 name=
"syscalls_info",
2033 printer=
"host_address_to_string (gdbarch->syscalls_info)",
2038SystemTap related fields and functions.
2039A NULL-terminated array of prefixes used to mark an integer constant
2040on the architecture's assembly.
2041For example, on x86 integer constants are written as:
2043$10 ;; integer constant 10
2045in this case, this prefix would be the character `$'.
2047 type=
"const char *const *",
2048 name=
"stap_integer_prefixes",
2051 printer=
"pstring_list (gdbarch->stap_integer_prefixes)",
2056A NULL-terminated array of suffixes used to mark an integer constant
2057on the architecture's assembly.
2059 type=
"const char *const *",
2060 name=
"stap_integer_suffixes",
2063 printer=
"pstring_list (gdbarch->stap_integer_suffixes)",
2068A NULL-terminated array of prefixes used to mark a register name on
2069the architecture's assembly.
2070For example, on x86 the register name is written as:
2074in this case, this prefix would be the character `%'.
2076 type=
"const char *const *",
2077 name=
"stap_register_prefixes",
2080 printer=
"pstring_list (gdbarch->stap_register_prefixes)",
2085A NULL-terminated array of suffixes used to mark a register name on
2086the architecture's assembly.
2088 type=
"const char *const *",
2089 name=
"stap_register_suffixes",
2092 printer=
"pstring_list (gdbarch->stap_register_suffixes)",
2097A NULL-terminated array of prefixes used to mark a register
2098indirection on the architecture's assembly.
2099For example, on x86 the register indirection is written as:
2101(%eax) ;; indirecting eax
2103in this case, this prefix would be the charater `('.
2105Please note that we use the indirection prefix also for register
2106displacement, e.g., `4(%eax)' on x86.
2108 type=
"const char *const *",
2109 name=
"stap_register_indirection_prefixes",
2112 printer=
"pstring_list (gdbarch->stap_register_indirection_prefixes)",
2117A NULL-terminated array of suffixes used to mark a register
2118indirection on the architecture's assembly.
2119For example, on x86 the register indirection is written as:
2121(%eax) ;; indirecting eax
2123in this case, this prefix would be the charater `)'.
2125Please note that we use the indirection suffix also for register
2126displacement, e.g., `4(%eax)' on x86.
2128 type=
"const char *const *",
2129 name=
"stap_register_indirection_suffixes",
2132 printer=
"pstring_list (gdbarch->stap_register_indirection_suffixes)",
2137Prefix(es) used to name a register using GDB's nomenclature.
2139For example, on PPC a register is represented by a number in the assembly
2140language (e.g., `10' is the 10th general-purpose register). However,
2141inside GDB this same register has an `r' appended to its name, so the 10th
2142register would be represented as `r10
' internally.
2144 type="const char *",
2145 name=
"stap_gdb_register_prefix",
2148 printer=
"pstring (gdbarch->stap_gdb_register_prefix)",
2153Suffix used to name a register using GDB's nomenclature.
2155 type=
"const char *",
2156 name=
"stap_gdb_register_suffix",
2159 printer=
"pstring (gdbarch->stap_gdb_register_suffix)",
2164Check if S is a single operand.
2166Single operands can be:
2167- Literal integers, e.g. `$10' on x86
2168- Register access, e.g. `%eax' on x86
2169- Register indirection, e.g. `(%eax)' on x86
2170- Register displacement, e.g. `4(%eax)' on x86
2172This function should check for these patterns on the string
2173and return 1 if some were found, or zero otherwise. Please try to match
2174as much info
as you can
from the string, i.e.,
if you have to match
2175something like `(%
', do not match just the `('.
2178 name=
"stap_is_single_operand",
2179 params=[(
"const char *",
"s")],
2186Function used to handle a "special case" in the parser.
2188A "special case" is considered to be an unknown token, i.e., a token
2189that the parser does not know how to parse. A good example of special
2190case would be ARM's register displacement syntax:
2194Since the parser assumes that a register displacement
is of the form:
2196<number> <indirection_prefix> <register_name> <indirection_suffix>
2198it means that it will
not be able to recognize
and parse this odd syntax.
2199Therefore, we should add a special case function that will handle this token.
2201This function should generate the proper expression form of the expression
2202using GDB
's internal expression mechanism (e.g., `write_exp_elt_opcode'
2203and so on). It should also
return 1
if the parsing was successful,
or zero
2204if the token was
not recognized
as a special token (
in this case, returning
2205zero means that the special parser
is deferring the parsing to the generic
2206parser),
and should advance the buffer pointer (p->arg).
2208 type="expr::operation_up",
2209 name=
"stap_parse_special_token",
2210 params=[(
"struct stap_parse_info *",
"p")],
2217Perform arch-dependent adjustments to a register name.
2219In very specific situations, it may be necessary for the register
2220name present in a SystemTap probe's argument to be handled in a
2221special way. For example, on i386, GCC may over-optimize the
2222register allocation and use smaller registers than necessary. In
2223such cases, the client that
is reading
and evaluating the SystemTap
2224probe (ourselves) will need to actually fetch values
from the wider
2225version of the register
in question.
2227To illustrate the example, consider the following probe argument
2232This argument says that its value can be found at the %ax register,
2233which
is a 16-bit register. However, the argument
's prefix says
2234that its type is "uint32_t", which
is 32-bit
in size. Therefore,
in
2235this case, GDB should actually fetch the probe
's value from register
2236%eax, not %ax. In this scenario, this function would actually
2237replace the register name
from %ax to %eax.
2239The rationale
for this can be found at PR breakpoints/24541.
2242 name=
"stap_adjust_register",
2244 (
"struct stap_parse_info *",
"p"),
2245 (
"const std::string &",
"regname"),
2254DTrace related functions.
2255The expression to compute the NARTGth+1 argument to a DTrace USDT probe.
2258 type=
"expr::operation_up",
2259 name=
"dtrace_parse_probe_argument",
2260 params=[(
"int",
"narg")],
2267True if the given ADDR does not contain the instruction sequence
2268corresponding to a disabled DTrace is-enabled probe.
2271 name=
"dtrace_probe_is_enabled",
2272 params=[(
"CORE_ADDR",
"addr")],
2279Enable a DTrace is-enabled probe at ADDR.
2282 name=
"dtrace_enable_probe",
2283 params=[(
"CORE_ADDR",
"addr")],
2290Disable a DTrace is-enabled probe at ADDR.
2293 name=
"dtrace_disable_probe",
2294 params=[(
"CORE_ADDR",
"addr")],
2301True if the list of shared libraries is one and only for all
2302processes, as opposed to a list of shared libraries per inferior.
2303This usually means that all processes, although may or may not share
2304an address space, will see the same set of symbols at the same
2308 name=
"has_global_solist",
2315On some targets, even though each inferior has its own private
2316address space, the debug interface takes care of making breakpoints
2317visible to all address spaces automatically. For such cases,
2318this property should be set to true.
2321 name=
"has_global_breakpoints",
2328True if inferiors share an address space (e.g., uClinux).
2331 name=
"has_shared_address_space",
2333 predefault=
"default_has_shared_address_space",
2339True if a fast tracepoint can be set at an address.
2342 name=
"fast_tracepoint_valid_at",
2343 params=[(
"CORE_ADDR",
"addr"), (
"std::string *",
"msg")],
2344 predefault=
"default_fast_tracepoint_valid_at",
2350Guess register state based on tracepoint location. Used for tracepoints
2351where no registers have been collected, but there
's only one location,
2352allowing us to guess the PC value, and perhaps some other registers.
2353On entry, regcache has all registers marked
as unavailable.
2356 name=
"guess_tracepoint_registers",
2357 params=[(
"struct regcache *",
"regcache"), (
"CORE_ADDR",
"addr")],
2358 predefault=
"default_guess_tracepoint_registers",
2364Return the "auto" target charset.
2366 type=
"const char *",
2367 name=
"auto_charset",
2369 predefault=
"default_auto_charset",
2375Return the "auto" target wide charset.
2377 type=
"const char *",
2378 name=
"auto_wide_charset",
2380 predefault=
"default_auto_wide_charset",
2386If non-empty, this is a file extension that will be opened in place
2387of the file extension reported by the shared library list.
2389This is most useful for toolchains that use a post-linker tool,
2390where the names of the files run on the target differ in extension
2391compared to the names of the files GDB should load for debug info.
2393 type=
"const char *",
2394 name=
"solib_symbols_extension",
2396 printer=
"pstring (gdbarch->solib_symbols_extension)",
2401If true, the target OS has DOS-based file system semantics. That
2402is, absolute paths include a drive name,
and the backslash
is
2403considered a directory separator.
2406 name=
"has_dos_based_file_system",
2413Generate bytecodes to collect the return address in a frame.
2414Since the bytecodes run on the target, possibly with GDB not even
2415connected, the full unwinding machinery is not available, and
2416typically this function will issue bytecodes for one or more likely
2417places that the return address may be found.
2420 name=
"gen_return_address",
2422 (
"struct agent_expr *",
"ax"),
2423 (
"struct axs_value *",
"value"),
2424 (
"CORE_ADDR",
"scope"),
2426 predefault=
"default_gen_return_address",
2432Implement the "info proc" command.
2436 params=[(
"const char *",
"args"), (
"enum info_proc_what",
"what")],
2443Implement the "info proc" command for core files. Noe that there
2444are two "info_proc"-like methods on gdbarch -- one
for core files,
2445one
for live targets.
2448 name=
"core_info_proc",
2449 params=[(
"const char *",
"args"), (
"enum info_proc_what",
"what")],
2456Iterate over all objfiles in the order that makes the most sense
2457for the architecture to make global symbol searches.
2459CB is a callback function passed an objfile to be searched. The iteration stops
2460if this function returns nonzero.
2462If
not NULL, CURRENT_OBJFILE corresponds to the objfile being
2463inspected when the symbol search was requested.
2466 name=
"iterate_over_objfiles_in_search_order",
2468 (
"iterate_over_objfiles_in_search_order_cb_ftype",
"cb"),
2469 (
"struct objfile *",
"current_objfile"),
2471 predefault=
"default_iterate_over_objfiles_in_search_order",
2477Ravenscar arch-dependent ops.
2479 type=
"struct ravenscar_arch_ops *",
2480 name=
"ravenscar_ops",
2483 printer=
"host_address_to_string (gdbarch->ravenscar_ops)",
2488Return non-zero if the instruction at ADDR is a call; zero otherwise.
2491 name=
"insn_is_call",
2492 params=[(
"CORE_ADDR",
"addr")],
2493 predefault=
"default_insn_is_call",
2499Return non-zero if the instruction at ADDR is a return; zero otherwise.
2503 params=[(
"CORE_ADDR",
"addr")],
2504 predefault=
"default_insn_is_ret",
2510Return non-zero if the instruction at ADDR is a jump; zero otherwise.
2513 name=
"insn_is_jump",
2514 params=[(
"CORE_ADDR",
"addr")],
2515 predefault=
"default_insn_is_jump",
2521Return true if there's a program/permanent breakpoint planted in
2522memory at ADDRESS, return false otherwise.
2525 name=
"program_breakpoint_here_p",
2526 params=[(
"CORE_ADDR",
"address")],
2527 predefault=
"default_program_breakpoint_here_p",
2533Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
2534Return 0 if *READPTR is already at the end of the buffer.
2535Return -1 if there is insufficient buffer for a whole entry.
2536Return 1 if an entry was read into *TYPEP and *VALP.
2541 (
"const gdb_byte **",
"readptr"),
2542 (
"const gdb_byte *",
"endptr"),
2543 (
"CORE_ADDR *",
"typep"),
2544 (
"CORE_ADDR *",
"valp"),
2552Print the description of a single auxv entry described by TYPE and VAL
2556 name=
"print_auxv_entry",
2557 params=[(
"struct ui_file *",
"file"), (
"CORE_ADDR",
"type"), (
"CORE_ADDR",
"val")],
2558 predefault=
"default_print_auxv_entry",
2564Find the address range of the current inferior's vsyscall/vDSO, and
2565write it to *RANGE. If the vsyscall's length can't be determined, a
2566range
with zero length
is returned. Returns true
if the vsyscall
is
2567found, false otherwise.
2570 name=
"vsyscall_range",
2571 params=[(
"struct mem_range *",
"range")],
2572 predefault=
"default_vsyscall_range",
2578Allocate SIZE bytes of PROT protected page aligned memory in inferior.
2579PROT has GDB_MMAP_PROT_* bitmask format.
2580Throw an error if it is not possible. Returned address is always valid.
2583 name=
"infcall_mmap",
2584 params=[(
"CORE_ADDR",
"size"), (
"unsigned",
"prot")],
2585 predefault=
"default_infcall_mmap",
2591Deallocate SIZE bytes of memory at ADDR in inferior from gdbarch_infcall_mmap.
2592Print a warning if it is not possible.
2595 name=
"infcall_munmap",
2596 params=[(
"CORE_ADDR",
"addr"), (
"CORE_ADDR",
"size")],
2597 predefault=
"default_infcall_munmap",
2603Return string (caller has to use xfree for it) with options for GCC
2604to produce code for this target, typically "-m64", "-m32" or "-m31".
2605These options are put before CU's DW_AT_producer compilation options so that
2606they can override it.
2609 name=
"gcc_target_options",
2611 predefault=
"default_gcc_target_options",
2617Return a regular expression that matches names used by this
2618architecture in GNU configury triplets. The result is statically
2619allocated
and must
not be freed. The default implementation simply
2620returns the BFD architecture name, which
is correct
in nearly every
2623 type="const char *",
2624 name=
"gnu_triplet_regexp",
2626 predefault=
"default_gnu_triplet_regexp",
2632Return the size in 8-bit bytes of an addressable memory unit on this
2633architecture. This corresponds to the number of 8-bit bytes associated to
2634each address in memory.
2637 name=
"addressable_memory_unit_size",
2639 predefault=
"default_addressable_memory_unit_size",
2645Functions for allowing a target to modify its disassembler options.
2647 type=
"const char *",
2648 name=
"disassembler_options_implicit",
2651 printer=
"pstring (gdbarch->disassembler_options_implicit)",
2656 name=
"disassembler_options",
2659 printer=
"pstring_ptr (gdbarch->disassembler_options)",
2663 type=
"const disasm_options_and_args_t *",
2664 name=
"valid_disassembler_options",
2667 printer=
"host_address_to_string (gdbarch->valid_disassembler_options)",
2672Type alignment override method. Return the architecture specific
2673alignment required for TYPE. If there
is no special handling
2674required
for TYPE then
return the value 0, GDB will then apply the
2675default rules
as laid out
in gdbtypes.c:type_align.
2679 params=[(
"struct type *",
"type")],
2680 predefault=
"default_type_align",
2686Return a string containing any flags for the given PC in the given FRAME.
2689 name=
"get_pc_address_flags",
2690 params=[(
"frame_info_ptr",
"frame"), (
"CORE_ADDR",
"pc")],
2691 predefault=
"default_get_pc_address_flags",
2697Read core file mappings
2700 name=
"read_core_file_mappings",
2702 (
"struct bfd *",
"cbfd"),
2703 (
"read_core_file_mappings_pre_loop_ftype",
"pre_loop_cb"),
2704 (
"read_core_file_mappings_loop_ftype",
"loop_cb"),
2706 predefault=
"default_read_core_file_mappings",