29#include "gdbsupport/selftest.h"
42 gdb_assert (arch !=
nullptr);
51 return gdbarch_tdep<amdgpu_gdbarch_tdep> (arch);
59 const gdb_byte *writebuf)
61 gdb_assert_not_reached (
"not implemented");
96 amd_dbgapi_register_exists_t register_exists;
99 != AMD_DBGAPI_STATUS_SUCCESS
100 || register_exists != AMD_DBGAPI_REGISTER_PRESENT)
115 if (dwarf_reg < tdep->dwarf_regnum_to_gdb_regnum.size ())
251 unsigned int bit_pos_end,
258 container_type::size_type
size ()
const
270 const std::string &
name ()
const
275 std::string res = string_printf (
"flags%d_t ",
bits);
276 res.append (
name.data (),
name.size ());
287 = std::unique_ptr<amd_dbgapi_register_type_flags>;
314 container_type::size_type
size ()
const
326 const std::string &
name ()
const
331 std::string res =
"enum ";
332 res.append (
name.data (),
name.length ());
343 = std::unique_ptr<amd_dbgapi_register_type_enum>;
347 = std::unordered_map<std::string, amd_dbgapi_register_type_up>;
355 ULONGEST
value = strtoulst (s.data (),
nullptr, 0);
357 error (_(
"Failed to parse integer."));
363#define IDENTIFIER "[A-Za-z0-9_.]+"
365#define WSOPT "[ \t]*"
378 compiled_regex regex (
385 _(
"Error in AMDGPU enum register type regex"));
386 regmatch_t matches[4];
388 while (!fields.empty ())
390 int res = regex.exec (fields.data (), ARRAY_SIZE (matches), matches, 0);
391 if (res == REG_NOMATCH)
392 error (_(
"Failed to parse enum fields"));
394 auto sv_from_match = [fields] (
const regmatch_t &m)
395 {
return fields.substr (m.rm_so, m.rm_eo - m.rm_so); };
397 gdb::string_view
name = sv_from_match (matches[1]);
398 gdb::string_view value_str = sv_from_match (matches[2]);
401 if (
value > std::numeric_limits<uint32_t>::max ())
406 fields = fields.substr (matches[0].rm_eo);
415 int bits, gdb::string_view
name, gdb::string_view fields,
418 gdb_assert (
bits == 32 ||
bits == 64);
420 std::string regex_str
429 compiled_regex regex (regex_str.c_str (), REG_EXTENDED,
430 _(
"Error in AMDGPU register type flags fields regex"));
431 regmatch_t matches[6];
433 while (!fields.empty ())
435 int res = regex.exec (fields.data (), ARRAY_SIZE (matches), matches, 0);
436 if (res == REG_NOMATCH)
437 error (_(
"Failed to parse flags type fields string"));
439 auto sv_from_match = [fields] (
const regmatch_t &m)
440 {
return fields.substr (m.rm_so, m.rm_eo - m.rm_so); };
442 gdb::string_view field_type_str = sv_from_match (matches[1]);
443 gdb::string_view
field_name = sv_from_match (matches[3]);
444 gdb::string_view pos_begin_str = sv_from_match (matches[4]);
447 if (field_type_str ==
"bool")
452 if (matches[5].rm_so == -1)
453 error (_(
"Missing end bit position"));
455 gdb::string_view pos_end_str = sv_from_match (matches[5]);
463 fields = fields.substr (matches[0].rm_eo);
473 std::string name_str = gdb::to_string (
name);
474 auto it = type_map.find (name_str);
475 if (it != type_map.end ())
482 error (_(
"type mismatch"));
488 if (
name ==
"int32_t")
490 else if (
name ==
"uint32_t")
492 else if (
name ==
"int64_t")
494 else if (
name ==
"uint64_t")
496 else if (
name ==
"float")
498 else if (
name ==
"double")
500 else if (
name ==
"void (*)()")
503 error (_(
"unknown type %s"), name_str.c_str ());
505 auto insertion_pair = type_map.emplace (
name, std::move (
type));
506 return *insertion_pair.first->second;
519 size_t pos_open_bracket = type_str.find_last_of (
'[');
520 auto sv_from_match = [type_str] (
const regmatch_t &m)
521 {
return type_str.substr (m.rm_so, m.rm_eo - m.rm_so); };
523 if (pos_open_bracket != gdb::string_view::npos)
526 gdb::string_view element_type_str
527 = type_str.substr (0, pos_open_bracket);
531 size_t pos_close_bracket = type_str.find_last_of (
']');
532 gdb_assert (pos_close_bracket != gdb::string_view::npos);
533 gdb::string_view count_str_view
534 = type_str.substr (pos_open_bracket + 1,
535 pos_close_bracket - pos_open_bracket);
536 std::string count_str = gdb::to_string (count_str_view);
537 unsigned int count = std::stoul (count_str);
539 std::string lookup_name
541 auto existing_type_it = type_map.find (lookup_name);
542 if (existing_type_it != type_map.end ())
544 gdb_assert (existing_type_it->second->kind ()
546 return *existing_type_it->second;
552 = type_map.emplace (
type->lookup_name (), std::move (
type));
553 return *insertion_pair.first->second;
556 if (type_str.find (
"flags32_t") == 0 || type_str.find (
"flags64_t") == 0)
559 compiled_regex regex (
"^(flags32_t|flags64_t)"
561 "(\\{" WSOPT "(.*)})?",
563 _(
"Error in AMDGPU register type regex"));
565 regmatch_t matches[5];
566 int res = regex.exec (type_str.data (), ARRAY_SIZE (matches), matches, 0);
567 if (res == REG_NOMATCH)
568 error (_(
"Failed to parse flags type string"));
570 gdb::string_view flags_keyword = sv_from_match (matches[1]);
571 unsigned int bit_size = flags_keyword ==
"flags32_t" ? 32 : 64;
572 gdb::string_view
name = sv_from_match (matches[2]);
573 std::string lookup_name
575 auto existing_type_it = type_map.find (lookup_name);
577 if (matches[3].rm_so == -1)
580 if (existing_type_it == type_map.end ())
581 error (_(
"reference to unknown type %s."),
582 gdb::to_string (
name).c_str ());
584 if (existing_type_it->second->kind ()
586 error (_(
"type mismatch"));
588 return *existing_type_it->second;
593 if (existing_type_it != type_map.end ())
594 error (_(
"re-definition of type %s."),
595 gdb::to_string (
name).c_str ());
599 gdb::string_view fields_without_braces = sv_from_match (matches[4]);
602 (*flags_type, bit_size,
name, fields_without_braces, type_map);
605 = type_map.emplace (flags_type->lookup_name (),
606 std::move (flags_type));
607 return *insertion_pair.first->second;
611 if (type_str.find (
"enum") == 0)
615 _(
"Error in AMDGPU register type enum regex"));
618 regmatch_t matches[4];
619 int res = regex.exec (type_str.data (), ARRAY_SIZE (matches), matches, 0);
620 if (res == REG_NOMATCH)
621 error (_(
"Failed to parse flags type string"));
623 gdb::string_view
name = sv_from_match (matches[1]);
625 std::string lookup_name
627 auto existing_type_it = type_map.find (lookup_name);
629 if (matches[2].rm_so == -1)
632 if (existing_type_it == type_map.end ())
633 error (_(
"reference to unknown type %s"),
634 gdb::to_string (
name).c_str ());
636 if (existing_type_it->second->kind ()
638 error (_(
"type mismatch"));
640 return *existing_type_it->second;
645 if (existing_type_it != type_map.end ())
646 error (_(
"re-definition of type %s"),
647 gdb::to_string (
name).c_str ());
651 gdb::string_view fields_without_braces = sv_from_match (matches[3]);
654 (*enum_type, fields_without_braces);
657 = type_map.emplace (enum_type->lookup_name (),
658 std::move (enum_type));
659 return *insertion_pair.first->second;
672 switch (
type.kind ())
676 const auto &integer_type
677 = gdb::checked_static_cast<const amd_dbgapi_register_type_integer &>
679 switch (integer_type.bit_size ())
682 if (integer_type.is_unsigned ())
688 if (integer_type.is_unsigned ())
694 gdb_assert_not_reached (
"invalid bit size");
700 const auto &vector_type
701 = gdb::checked_static_cast<const amd_dbgapi_register_type_vector &>
703 struct type *element_type
720 const auto &flags_type
721 = gdb::checked_static_cast<const amd_dbgapi_register_type_flags &>
723 struct type *gdb_type
725 flags_type.bit_size ());
727 for (
const auto &
field : flags_type)
731 gdb_assert (
field.bit_pos_start ==
field.bit_pos_end);
737 struct type *field_type
739 gdb_assert (field_type !=
nullptr);
741 (gdb_type,
field.bit_pos_start,
752 const auto &enum_type
753 = gdb::checked_static_cast<const amd_dbgapi_register_type_enum &>
755 struct type *gdb_type
757 .
new_type (TYPE_CODE_ENUM, enum_type.bit_size (),
758 enum_type.name ().c_str ()));
763 for (
size_t i = 0; i < enum_type.size (); ++i)
765 const auto &
field = enum_type[i];
774 gdb_assert_not_reached (
"unhandled amd_dbgapi_register_type kind");
789 amd_dbgapi_status_t
status
791 AMD_DBGAPI_REGISTER_INFO_TYPE,
792 sizeof (bytes), &bytes);
793 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
794 error (_(
"Failed to get register type from amd-dbgapi"));
796 gdb::unique_xmalloc_ptr<char> bytes_holder (bytes);
818 amd_dbgapi_register_class_state_t state;
819 if (amd_dbgapi_register_is_in_register_class (it->second,
822 != AMD_DBGAPI_STATUS_SUCCESS)
825 return (state == AMD_DBGAPI_REGISTER_CLASS_STATE_MEMBER
835static const gdb_byte *
851 if (*this_cache !=
nullptr)
856 (*this_cache) = cache;
916 gdb::byte_vector buffer (instruction_size);
923 while (instruction_size > 0)
925 int ret =
info->read_memory_func (memaddr, buffer.data (),
926 instruction_size,
info);
933 if (instruction_size == 0)
935 info->memory_error_func (-1, memaddr, info);
939 amd_dbgapi_architecture_id_t architecture_id;
940 amd_dbgapi_status_t
status
943 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
946 auto symbolizer = [] (amd_dbgapi_symbolizer_id_t symbolizer_id,
947 amd_dbgapi_global_address_t
address,
948 char **symbol_text) -> amd_dbgapi_status_t
954 gdb_assert (disasm !=
nullptr);
958 *symbol_text = xstrdup (
string.c_str ());
960 return AMD_DBGAPI_STATUS_SUCCESS;
962 auto symbolizer_id =
reinterpret_cast<amd_dbgapi_symbolizer_id_t
> (di);
963 char *instruction_text =
nullptr;
964 status = amd_dbgapi_disassemble_instruction (architecture_id, memaddr,
970 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
973 status = amd_dbgapi_architecture_get_info
975 AMD_DBGAPI_ARCHITECTURE_INFO_MINIMUM_INSTRUCTION_ALIGNMENT,
976 sizeof (alignment), &alignment);
977 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
978 error (_(
"amd_dbgapi_architecture_get_info failed"));
980 info->fprintf_func (di,
"<illegal instruction>");
983 return align_up (memaddr + 1, alignment) - memaddr;
987 info->fprintf_func (di,
"%s", instruction_text);
990 xfree (instruction_text);
992 return static_cast<int> (instruction_size);
1005 CORE_ADDR post_prologue_pc
1011 if (post_prologue_pc != 0
1015 return std::max (start_pc, post_prologue_pc);
1024 amd_dbgapi_architecture_id_t architecture_id;
1025 amd_dbgapi_status_t
status
1026 = amd_dbgapi_get_architecture (
info->mach, &architecture_id);
1028 gdb_assert (
status != AMD_DBGAPI_STATUS_ERROR_NOT_INITIALIZED);
1029 return status == AMD_DBGAPI_STATUS_SUCCESS;
1070 amd_dbgapi_architecture_id_t architecture_id;
1071 amd_dbgapi_status_t
status
1074 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
1076 warning (_(
"Failed to get architecture from amd-dbgapi"));
1082 size_t register_class_count;
1083 amd_dbgapi_register_class_id_t *register_class_ids;
1084 status = amd_dbgapi_architecture_register_class_list (architecture_id,
1085 ®ister_class_count,
1086 ®ister_class_ids);
1087 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
1089 warning (_(
"Failed to get register class list from amd-dbgapi"));
1093 gdb::unique_xmalloc_ptr<amd_dbgapi_register_class_id_t>
1094 register_class_ids_holder (register_class_ids);
1096 for (
size_t i = 0; i < register_class_count; ++i)
1099 status = amd_dbgapi_architecture_register_class_get_info
1100 (register_class_ids[i], AMD_DBGAPI_REGISTER_CLASS_INFO_NAME,
1101 sizeof (bytes), &bytes);
1102 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
1104 warning (_(
"Failed to get register class name from amd-dbgapi"));
1108 gdb::unique_xmalloc_ptr<char>
name (bytes);
1111 register_class_ids[i]);
1112 gdb_assert (inserted.second);
1125 size_t register_count;
1126 amd_dbgapi_register_id_t *register_ids;
1127 status = amd_dbgapi_architecture_register_list (architecture_id,
1130 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
1132 warning (_(
"Failed to get register list from amd-dbgapi"));
1136 gdb::unique_xmalloc_ptr<amd_dbgapi_register_id_t> register_ids_holder
1140 ®ister_ids[register_count]);
1143 AMD_DBGAPI_REGISTER_PROPERTY_NONE);
1147 if (amd_dbgapi_register_get_info (register_ids[
regnum],
1148 AMD_DBGAPI_REGISTER_INFO_PROPERTIES,
1149 sizeof (register_properties),
1150 ®ister_properties)
1151 != AMD_DBGAPI_STATUS_SUCCESS)
1153 warning (_(
"Failed to get register properties from amd-dbgapi"));
1163 for (
size_t i = 0; i < register_count; ++i)
1171 AMD_DBGAPI_REGISTER_INFO_NAME,
1172 sizeof (bytes), &bytes);
1173 if (
status == AMD_DBGAPI_STATUS_SUCCESS)
1182 AMD_DBGAPI_REGISTER_INFO_DWARF,
1183 sizeof (dwarf_num), &dwarf_num);
1184 if (
status == AMD_DBGAPI_STATUS_SUCCESS)
1193 amd_dbgapi_register_id_t pc_register_id;
1194 status = amd_dbgapi_architecture_get_info
1195 (architecture_id, AMD_DBGAPI_ARCHITECTURE_INFO_PC_REGISTER,
1196 sizeof (pc_register_id), &pc_register_id);
1197 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
1199 warning (_(
"Failed to get PC register from amd-dbgapi"));
1221 amd_dbgapi_size_t max_insn_length = 0;
1222 status = amd_dbgapi_architecture_get_info
1223 (architecture_id, AMD_DBGAPI_ARCHITECTURE_INFO_LARGEST_INSTRUCTION_SIZE,
1224 sizeof (max_insn_length), &max_insn_length);
1225 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
1226 error (_(
"amd_dbgapi_architecture_get_info failed"));
1230 status = amd_dbgapi_architecture_get_info
1231 (architecture_id, AMD_DBGAPI_ARCHITECTURE_INFO_BREAKPOINT_INSTRUCTION_SIZE,
1234 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
1235 error (_(
"amd_dbgapi_architecture_get_info failed"));
1237 gdb_byte *breakpoint_instruction_bytes;
1238 status = amd_dbgapi_architecture_get_info
1239 (architecture_id, AMD_DBGAPI_ARCHITECTURE_INFO_BREAKPOINT_INSTRUCTION,
1240 sizeof (breakpoint_instruction_bytes), &breakpoint_instruction_bytes);
1241 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
1242 error (_(
"amd_dbgapi_architecture_get_info failed"));
1251 amd_dbgapi_size_t pc_adjust;
1252 status = amd_dbgapi_architecture_get_info
1254 AMD_DBGAPI_ARCHITECTURE_INFO_BREAKPOINT_INSTRUCTION_PC_ADJUST,
1255 sizeof (pc_adjust), &pc_adjust);
1256 if (
status != AMD_DBGAPI_STATUS_SUCCESS)
1257 error (_(
"amd_dbgapi_architecture_get_info failed"));
1261 return gdbarch_u.release ();
1264#if defined GDB_SELF_TEST
1267amdgpu_register_type_parse_test ()
1272 const char *flags_type_str =
1279 } FP_ROUND.32 @0-1; \
1280 enum fp_round FP_ROUND.64_16 @2-3; \
1282 FLUSH_SRC_DST = 0, \
1286 } FP_DENORM.32 @4-5; \
1287 enum fp_denorm FP_DENORM.64_16 @6-7; \
1288 bool DX10_CLAMP @8; \
1290 bool LOD_CLAMPED @10; \
1291 bool DEBUG_EN @11; \
1292 bool EXCP_EN.INVALID @12; \
1293 bool EXCP_EN.DENORM @13; \
1294 bool EXCP_EN.DIV0 @14; \
1295 bool EXCP_EN.OVERFLOW @15; \
1296 bool EXCP_EN.UNDERFLOW @16; \
1297 bool EXCP_EN.INEXACT @17; \
1298 bool EXCP_EN.INT_DIV0 @18; \
1299 bool EXCP_EN.ADDR_WATCH @19; \
1300 bool FP16_OVFL @23; \
1301 bool POPS_PACKER0 @24; \
1302 bool POPS_PACKER1 @25; \
1303 bool DISABLE_PERF @26; \
1304 bool GPR_IDX_EN @27; \
1306 uint32_t CSP @29-31; \
1315 = gdb::checked_static_cast<const amd_dbgapi_register_type_flags &> (
type);
1316 gdb_assert (
f.size () == 23);
1319 auto check_fp_round_field
1327 = gdb::checked_static_cast<const amd_dbgapi_register_type_enum &>
1329 gdb_assert (e.size () == 4);
1330 gdb_assert (e[0].
name ==
"NEAREST_EVEN");
1331 gdb_assert (e[0].
value == 0);
1332 gdb_assert (e[3].
name ==
"ZERO");
1333 gdb_assert (e[3].
value == 3);
1336 check_fp_round_field (
"FP_ROUND.32",
f[0]);
1337 check_fp_round_field (
"FP_ROUND.64_16",
f[1]);
1340 gdb_assert (
f[22].
name ==
"CSP");
1344 = gdb::checked_static_cast<const amd_dbgapi_register_type_integer &>
1346 gdb_assert (i.bit_size () == 32);
1347 gdb_assert (i.is_unsigned ());
1352 const char *vector_type_str =
"int32_t[64]";
1360 = gdb::checked_static_cast<const amd_dbgapi_register_type_vector &>
1362 gdb_assert (v.count () == 64);
1364 const auto &et = v.element_type ();
1368 = gdb::checked_static_cast<const amd_dbgapi_register_type_integer &> (et);
1369 gdb_assert (i.bit_size () == 32);
1370 gdb_assert (!i.is_unsigned ());
1383#if defined GDB_SELF_TEST
1384 selftests::register_test (
"amdgpu-register-type-parse-flags-fields",
1385 amdgpu_register_type_parse_test);
#define bits(obj, st, fn)
static bool ptid_is_gpu(ptid_t ptid)
static amd_dbgapi_wave_id_t get_amd_dbgapi_wave_id(ptid_t ptid)
void _initialize_amdgpu_tdep()
static amdgpu_frame_cache * amdgpu_frame_cache(frame_info_ptr this_frame, void **this_cache)
static struct gdbarch * amdgpu_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
std::unique_ptr< amd_dbgapi_register_type_flags > amd_dbgapi_register_type_flags_up
static int amdgpu_breakpoint_kind_from_pc(struct gdbarch *gdbarch, CORE_ADDR *)
static void parse_amd_dbgapi_register_type_enum_fields(amd_dbgapi_register_type_enum &enum_type, gdb::string_view fields)
static ULONGEST try_strtoulst(gdb::string_view s)
static const amd_dbgapi_register_type & parse_amd_dbgapi_register_type(gdb::string_view type_name, amd_dbgapi_register_type_map &type_map)
static const amd_dbgapi_register_type & parse_amd_dbgapi_register_type_scalar(gdb::string_view name, amd_dbgapi_register_type_map &type_map)
static const char * amdgpu_register_name(struct gdbarch *gdbarch, int regnum)
static void parse_amd_dbgapi_register_type_flags_fields(amd_dbgapi_register_type_flags &flags_type, int bits, gdb::string_view name, gdb::string_view fields, amd_dbgapi_register_type_map &type_map)
static type * amdgpu_register_type(struct gdbarch *gdbarch, int regnum)
static return_value_convention amdgpu_return_value_as_value(gdbarch *arch, value *function, type *valtype, regcache *regcache, value **read_value, const gdb_byte *writebuf)
std::unique_ptr< amd_dbgapi_register_type > amd_dbgapi_register_type_up
amdgpu_gdbarch_tdep * get_amdgpu_gdbarch_tdep(gdbarch *arch)
static frame_id amdgpu_dummy_id(struct gdbarch *gdbarch, frame_info_ptr this_frame)
bool is_amdgpu_arch(struct gdbarch *arch)
static int amdgpu_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const reggroup *group)
static bool amdgpu_supports_arch_info(const struct bfd_arch_info *info)
std::unique_ptr< amd_dbgapi_register_type_enum > amd_dbgapi_register_type_enum_up
static void amdgpu_frame_this_id(frame_info_ptr this_frame, void **this_cache, frame_id *this_id)
static type * amd_dbgapi_register_type_to_gdb_type(const amd_dbgapi_register_type &type, struct gdbarch *gdbarch)
static int amdgpu_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int dwarf_reg)
static const frame_unwind amdgpu_frame_unwind
static int print_insn_amdgpu(bfd_vma memaddr, struct disassemble_info *info)
static struct value * amdgpu_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static CORE_ADDR amdgpu_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc)
static const gdb_byte * amdgpu_sw_breakpoint_from_kind(struct gdbarch *gdbarch, int kind, int *size)
std::unordered_map< std::string, amd_dbgapi_register_type_up > amd_dbgapi_register_type_map
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
static std::vector< const char * > arches
int core_addr_greaterthan(CORE_ADDR lhs, CORE_ADDR rhs)
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
virtual bool can_emit_style_escape()
void print_address(struct gdbarch *, CORE_ADDR, struct ui_file *)
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
const struct frame_id outer_frame_id
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
struct value * frame_unwind_got_register(frame_info_ptr frame, int regnum, int new_regnum)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
int frame_relative_level(frame_info_ptr fi)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
enum frame_type get_frame_type(frame_info_ptr frame)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
#define frame_debug_printf(fmt,...)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
void set_gdbarch_return_value_as_value(struct gdbarch *gdbarch, gdbarch_return_value_as_value_ftype *return_value_as_value)
void set_gdbarch_ps_regnum(struct gdbarch *gdbarch, int ps_regnum)
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
void set_gdbarch_half_format(struct gdbarch *gdbarch, const struct floatformat **half_format)
void set_gdbarch_max_insn_length(struct gdbarch *gdbarch, ULONGEST max_insn_length)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
void set_gdbarch_decr_pc_after_break(struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p)
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype *print_insn)
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum)
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id)
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
ULONGEST gdbarch_max_insn_length(struct gdbarch *gdbarch)
void set_gdbarch_float_format(struct gdbarch *gdbarch, const struct floatformat **float_format)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, gdbarch_tdep_up tdep)
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
std::unique_ptr< gdbarch, gdbarch_deleter > gdbarch_up
void append_flags_type_flag(struct type *type, int bitpos, const char *name)
struct type * arch_flags_type(struct gdbarch *gdbarch, const char *name, int bit)
struct type * init_vector_type(struct type *elt_type, int n)
void append_flags_type_field(struct type *type, int start_bitpos, int nr_bits, struct type *field_type, const char *name)
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
const struct floatformat * floatformats_ieee_half[BFD_ENDIAN_UNKNOWN]
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
bool producer_is_llvm(const char *producer)
static gdbpy_ref field_name(struct type *type, int field)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
const reggroup * reggroup_find(struct gdbarch *gdbarch, const char *name)
const reggroup *const all_reggroup
void reggroup_add(struct gdbarch *gdbarch, const reggroup *group)
const reggroup * reggroup_gdbarch_new(struct gdbarch *gdbarch, const char *name, enum reggroup_type type)
amd_dbgapi_register_type_code_ptr()
amd_dbgapi_register_type_double()
container_type::const_iterator const_iterator_type
const_iterator_type begin() const
container_type m_enumerators
void add_enumerator(std::string name, ULONGEST value)
const std::string & name() const
amd_dbgapi_register_type_enum(gdb::string_view name)
unsigned int bit_size() const
const enumerator & operator[](container_type::size_type pos) const
void set_bit_size(int bit_size)
std::vector< enumerator > container_type
static std::string make_lookup_name(gdb::string_view name)
container_type::size_type size() const
const_iterator_type end() const
const amd_dbgapi_register_type * type
unsigned int bit_pos_start
const_iterator_type end() const
container_type::const_iterator const_iterator_type
const field & operator[](container_type::size_type pos) const
amd_dbgapi_register_type_flags(unsigned int bit_size, gdb::string_view name)
const_iterator_type begin() const
void add_field(std::string name, unsigned int bit_pos_start, unsigned int bit_pos_end, const amd_dbgapi_register_type *type)
container_type::size_type size() const
const std::string & name() const
static std::string make_lookup_name(int bits, gdb::string_view name)
std::vector< field > container_type
unsigned int bit_size() const
amd_dbgapi_register_type_float()
amd_dbgapi_register_type_integer(bool is_unsigned, unsigned int bit_size)
unsigned int bit_size() const
amd_dbgapi_register_type_vector(const amd_dbgapi_register_type &element_type, unsigned int count)
const amd_dbgapi_register_type & element_type() const
const amd_dbgapi_register_type & m_element_type
static std::string make_lookup_name(const amd_dbgapi_register_type &element_type, unsigned int count)
unsigned int count() const
const std::string & lookup_name() const
amd_dbgapi_register_type(kind kind, std::string lookup_name)
virtual ~amd_dbgapi_register_type()=default
std::string m_lookup_name
std::vector< int > dwarf_regnum_to_gdb_regnum
std::unordered_map< std::string, amd_dbgapi_register_class_id_t > register_class_map
size_t breakpoint_instruction_size
std::vector< amd_dbgapi_register_id_t > register_ids
std::vector< type * > register_types
std::vector< std::string > register_names
gdb::unique_xmalloc_ptr< gdb_byte > breakpoint_instruction_bytes
std::unordered_map< amd_dbgapi_register_id_t, int, register_id_hash, register_id_equal_to > regnum_map
std::vector< amd_dbgapi_register_properties_t > register_properties
struct type * builtin_double
struct type * builtin_func_ptr
struct type * builtin_uint32
struct type * builtin_uint64
struct type * builtin_int64
struct type * builtin_int32
struct type * builtin_float
const char * producer() const
void set_loc_enumval(LONGEST enumval)
void set_name(const char *name)
const char * name() const
struct type * type() const
std::string to_string() const
struct ui_file * stream()
const char * name() const
struct field & field(int idx) const
void set_is_unsigned(bool is_unsigned)
void alloc_fields(unsigned int nfields, bool init=true)
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)