51#define INSN_OPCODE(insn) ((insn & 0xfc000000) >> 26)
54#define MEM_RA(insn) ((insn & 0x03e00000) >> 21)
55#define MEM_RB(insn) ((insn & 0x001f0000) >> 16)
56#define MEM_DISP(insn) \
57 (((insn & 0x8000) == 0) ? (insn & 0xffff) : -((-insn) & 0xffff))
63#define BR_RA(insn) MEM_RA(insn)
69#define OPR_FUNCTION(insn) ((insn & 0xfe0) >> 5)
70#define OPR_HAS_IMMEDIATE(insn) ((insn & 0x1000) == 0x1000)
71#define OPR_RA(insn) MEM_RA(insn)
72#define OPR_RC(insn) ((insn & 0x1f))
73#define OPR_LIT(insn) ((insn & 0x1fe000) >> 13)
89 static const char *
const register_names[] =
91 "v0",
"t0",
"t1",
"t2",
"t3",
"t4",
"t5",
"t6",
92 "t7",
"s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"fp",
93 "a0",
"a1",
"a2",
"a3",
"a4",
"a5",
"t8",
"t9",
94 "t10",
"t11",
"ra",
"t12",
"at",
"gp",
"sp",
"zero",
95 "f0",
"f1",
"f2",
"f3",
"f4",
"f5",
"f6",
"f7",
96 "f8",
"f9",
"f10",
"f11",
"f12",
"f13",
"f14",
"f15",
97 "f16",
"f17",
"f18",
"f19",
"f20",
"f21",
"f22",
"f23",
98 "f24",
"f25",
"f26",
"f27",
"f28",
"f29",
"f30",
"fpcr",
103 return register_names[regno];
186 ULONGEST frac = (mem >> 0) & 0x7fffff;
187 ULONGEST sign = (mem >> 31) & 1;
188 ULONGEST exp_msb = (mem >> 30) & 1;
189 ULONGEST exp_low = (mem >> 23) & 0x7f;
192 exp = (exp_msb << 10) | exp_low;
204 reg = (sign << 63) | (exp << 52) | (frac << 29);
218 mem = ((reg >> 32) & 0xc0000000) | ((reg >> 29) & 0x3fffffff);
238 struct type *valtype, gdb_byte *out,
239 int *optimizedp,
int *unavailablep)
244 gdb_assert (
value != NULL);
248 if (*optimizedp || *unavailablep)
256 gdb_assert (valtype->
length () == 4);
265 struct type *valtype,
const gdb_byte *in)
269 gdb_assert (valtype->
length () == 4);
293 int nargs,
struct value **args, CORE_ADDR sp,
295 CORE_ADDR struct_addr)
302 const gdb_byte *contents;
306 struct alpha_arg *alpha_args = XALLOCAVEC (
struct alpha_arg, nargs);
307 struct alpha_arg *m_arg;
309 int required_arg_regs;
320 for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
322 struct value *arg = args[i];
326 switch (arg_type->
code ())
331 case TYPE_CODE_RANGE:
333 if (arg_type->
length () == 4)
350 if (accumulate_size <
sizeof (arg_reg_buffer)
351 && arg_type->
length () == 4)
358 else if (arg_type->
length () == 16)
361 sp = (sp & -16) - 16;
372 case TYPE_CODE_COMPLEX:
379 if (arg_type->
length () == 32)
382 sp = (sp & -16) - 16;
396 m_arg->len = arg_type->
length ();
397 m_arg->offset = accumulate_size;
398 accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
404 required_arg_regs = accumulate_size / 8;
409 if (accumulate_size <
sizeof(arg_reg_buffer))
412 accumulate_size -=
sizeof(arg_reg_buffer);
413 sp -= accumulate_size;
419 for (i = nargs; m_arg--, --i >= 0;)
421 const gdb_byte *contents = m_arg->contents;
422 int offset = m_arg->offset;
423 int len = m_arg->len;
426 if (offset <
sizeof(arg_reg_buffer))
428 if (offset + len <=
sizeof(arg_reg_buffer))
430 memcpy (arg_reg_buffer + offset, contents, len);
435 int tlen =
sizeof(arg_reg_buffer) - offset;
436 memcpy (arg_reg_buffer + offset, contents, tlen);
444 write_memory (sp + offset -
sizeof(arg_reg_buffer), contents, len);
448 byte_order, struct_addr);
451 for (i = 0; i < required_arg_regs; i++)
477 switch (valtype->
code ())
480 switch (valtype->
length ())
497 internal_error (_(
"unknown floating point width"));
501 case TYPE_CODE_COMPLEX:
502 switch (valtype->
length ())
520 internal_error (_(
"unknown floating point width"));
537 const gdb_byte *valbuf)
543 switch (valtype->
code ())
546 switch (valtype->
length ())
561 error (_(
"Cannot set a 128-bit long double return value."));
564 internal_error (_(
"unknown floating point width"));
568 case TYPE_CODE_COMPLEX:
569 switch (valtype->
length ())
585 error (_(
"Cannot set a 128-bit long double return value."));
588 internal_error (_(
"unknown floating point width"));
596 if (valtype->
length () == 4)
607 gdb_byte *readbuf,
const gdb_byte *writebuf)
612 if ((
code == TYPE_CODE_STRUCT
613 ||
code == TYPE_CODE_UNION
614 ||
code == TYPE_CODE_ARRAY)
654 CORE_ADDR func_addr, func_end;
660 if (sal.
end < func_end)
695 CORE_ADDR post_prologue_pc;
713 if (post_prologue_pc != 0)
714 return std::max (
pc, post_prologue_pc);
726 if ((inst & 0xffff0000) == 0x27bb0000)
728 if ((inst & 0xffff0000) == 0x23bd0000)
730 if ((inst & 0xffff0000) == 0x23de0000)
732 if ((inst & 0xffe01fff) == 0x43c0153e)
735 if (((inst & 0xfc1f0000) == 0xb41e0000
736 || (inst & 0xfc1f0000) == 0x9c1e0000)
737 && (inst & 0x03e00000) != 0x03e00000)
740 if (inst == 0x47de040f)
742 if (inst == 0x47fe040f)
761static std::vector<CORE_ADDR>
764 CORE_ADDR breaks[2] = {CORE_ADDR_MAX, CORE_ADDR_MAX};
766 CORE_ADDR closing_insn;
770 int last_breakpoint = 0;
771 const int atomic_sequence_length = 16;
772 int bc_insn_count = 0;
781 for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
791 int immediate = (insn & 0x001fffff) << 2;
793 immediate = (immediate ^ 0x400000) - 0x400000;
795 if (bc_insn_count >= 1)
824 && (breaks[1] == breaks[0]
825 || (breaks[1] >=
pc && breaks[1] <= closing_insn)))
828 std::vector<CORE_ADDR> next_pcs;
830 for (index = 0; index <= last_breakpoint; index++)
831 next_pcs.push_back (breaks[index]);
875 void **this_prologue_cache)
879 if (*this_prologue_cache)
883 *this_prologue_cache = info;
916 void **this_prologue_cache,
923 CORE_ADDR stack_addr, code_addr;
926 if (info->sigcontext_addr == 0)
958 void **this_prologue_cache,
int regnum)
964 if (info->sigcontext_addr != 0)
968 info->sigcontext_addr,
regnum);
983 void **this_prologue_cache)
1037 CORE_ADDR last_non_nop = pc;
1039 CORE_ADDR orig_pc = pc;
1054 || fence < tdep->vm_min_address)
1067 return last_non_nop;
1086 static int blurb_printed = 0;
1089 warning (_(
"Hit beginning of text section without finding \
1092 warning (_(
"Hit heuristic-fence-post without finding \
1098This warning occurs if you are debugging a function without any symbols\n\
1099(for example, in a stripped executable). In that case, you may wish to\n\
1100increase the size of the search with the `set heuristic-fence-post' command.\n\
1102Otherwise, you told GDB there was a function where there isn't one, or\n\
1103(more likely) you have encountered a bug in GDB.\n"));
1130 CORE_ADDR cur_pc = *pc;
1131 int cur_frame_size = *frame_size;
1132 int nb_of_iterations, reg_index, reg_probe;
1157 reg_index =
MEM_RA (insn);
1158 nb_of_iterations =
MEM_DISP (insn);
1167 reg_probe =
MEM_RA (insn);
1176 ||
MEM_RB (insn) != reg_probe)
1187 ||
OPR_RA (insn) != reg_index
1188 ||
OPR_RC (insn) != reg_index)
1196 ||
MEM_RA (insn) != reg_probe
1197 ||
MEM_RB (insn) != reg_probe)
1199 cur_frame_size -=
MEM_DISP (insn) * nb_of_iterations;
1206 ||
MEM_RA (insn) != reg_index)
1215 ||
MEM_RB (insn) != reg_probe)
1220 *frame_size = cur_frame_size;
1225 void **this_prologue_cache,
1231 CORE_ADDR limit_pc, cur_pc;
1234 if (*this_prologue_cache)
1238 *this_prologue_cache = info;
1261 if ((word & 0xffff0000) == 0x23de0000)
1267 if (frame_size == 0)
1268 frame_size = (-word) & 0xffff;
1278 else if ((word & 0xfc1f0000) == 0xb41e0000)
1280 reg = (word & 0x03e00000) >> 21;
1289 if (info->saved_regs[reg].is_addr ())
1305 info->saved_regs[reg].set_addr ((word & 0xffff) + 1);
1334 else if ((word & 0xffe0ffff) == 0x6be08001)
1336 else if (word == 0x47de040f)
1338 else if (word == 0x47fe040f)
1348 while (cur_pc < (limit_pc + 80) && cur_pc < (
start_pc + 80))
1352 if ((word & 0xfc1f0000) == 0xb41e0000)
1354 reg = (word & 0x03e00000) >> 21;
1363 else if ((word & 0xffe0ffff) == 0x6be08001)
1380 info->vfp = val + frame_size;
1385 if (info->saved_regs[reg].is_addr ())
1386 info->saved_regs[reg].set_addr (info->saved_regs[reg].addr ()
1402 void **this_prologue_cache,
1413static struct value *
1415 void **this_prologue_cache,
int regnum)
1424 regnum = info->return_reg;
1442 void **this_prologue_cache)
1473 const void *r0_r30,
const void *pc,
const void *unique)
1475 const gdb_byte *regs = (
const gdb_byte *) r0_r30;
1478 for (i = 0; i < 31; ++i)
1479 if (regno == i || regno == -1)
1484 const gdb_byte zero[8] = { 0 };
1498 int regno,
void *r0_r30,
void *pc,
void *unique)
1500 gdb_byte *regs = (gdb_byte *) r0_r30;
1503 for (i = 0; i < 31; ++i)
1504 if (regno == i || regno == -1)
1516 const void *f0_f30,
const void *fpcr)
1518 const gdb_byte *regs = (
const gdb_byte *) f0_f30;
1522 if (regno == i || regno == -1)
1531 int regno,
void *f0_f30,
void *fpcr)
1533 gdb_byte *regs = (gdb_byte *) f0_f30;
1537 if (regno == i || regno == -1)
1553 const LONGEST zero_mask = ((LONGEST) 1 << 63) ^ -1;
1555 return ((reg & zero_mask) == 0);
1564 const LONGEST sign_mask = (LONGEST) 1 << 63;
1566 return ((reg & sign_mask) != 0);
1587 op = (insn >> 26) & 0x3f;
1593 return (regcache_raw_get_unsigned (
regcache, (insn >> 16) & 0x1f) & ~3);
1596 if ((op & 0x30) == 0x30)
1604 offset = (insn & 0x001fffff);
1605 if (offset & 0x00100000)
1606 offset |= 0xffe00000;
1612 regno = (insn >> 21) & 0x1f;
1695std::vector<CORE_ADDR>
1702 std::vector<CORE_ADDR> next_pcs
1704 if (!next_pcs.empty ())
1790 alpha_breakpoint::kind_from_pc);
1792 alpha_breakpoint::bp_from_kind);
1805 if (tdep->
jb_pc >= 0)
1839Set the distance searched for the start of a function."), _(
"\
1840Show the distance searched for the start of a function."), _(
"\
1841If you are debugging a stripped executable, GDB needs to search through the\n\
1842program for the start of a function. This command sets the distance of the\n\
1843search. The only need to set it is when debugging a stripped executable."),
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
unsigned int alpha_read_insn(struct gdbarch *gdbarch, CORE_ADDR pc)
static int alpha_sigtramp_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
static int alpha_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
void alpha_supply_int_regs(struct regcache *regcache, int regno, const void *r0_r30, const void *pc, const void *unique)
void alpha_supply_fp_regs(struct regcache *regcache, int regno, const void *f0_f30, const void *fpcr)
static const int bne_opcode
static struct value * alpha_sigtramp_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static CORE_ADDR alpha_heuristic_proc_start(struct gdbarch *gdbarch, CORE_ADDR pc)
void alpha_dwarf2_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static void alpha_sts(struct gdbarch *gdbarch, void *out, const void *in)
static const struct frame_base alpha_heuristic_frame_base
static const int ldl_l_opcode
static struct alpha_heuristic_unwind_cache * alpha_heuristic_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache, CORE_ADDR start_pc)
static struct value * alpha_heuristic_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
void alpha_fill_fp_regs(const struct regcache *regcache, int regno, void *f0_f30, void *fpcr)
static void alpha_value_to_register(frame_info_ptr frame, int regnum, struct type *valtype, const gdb_byte *in)
static void alpha_heuristic_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
static const int lda_opcode
static int alpha_convert_register_p(struct gdbarch *gdbarch, int regno, struct type *type)
constexpr gdb_byte alpha_break_insn[]
#define OPR_FUNCTION(insn)
static CORE_ADDR alpha_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static CORE_ADDR alpha_heuristic_frame_base_address(frame_info_ptr this_frame, void **this_prologue_cache)
static const int stq_opcode
static struct type * alpha_register_type(struct gdbarch *gdbarch, int regno)
static void alpha_extract_return_value(struct type *valtype, struct regcache *regcache, gdb_byte *valbuf)
static CORE_ADDR alpha_next_pc(struct regcache *regcache, CORE_ADDR pc)
static int fp_register_zero_p(LONGEST reg)
#define INSN_OPCODE(insn)
static void alpha_sigtramp_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
void alpha_fill_int_regs(const struct regcache *regcache, int regno, void *r0_r30, void *pc, void *unique)
static const char * alpha_register_name(struct gdbarch *gdbarch, int regno)
static CORE_ADDR alpha_sigtramp_register_address(struct gdbarch *gdbarch, CORE_ADDR sigcontext_addr, int regnum)
void _initialize_alpha_tdep()
static const struct frame_unwind alpha_sigtramp_frame_unwind
static int alpha_get_longjmp_target(frame_info_ptr frame, CORE_ADDR *pc)
static const int ldq_l_opcode
static void alpha_store_return_value(struct type *valtype, struct regcache *regcache, const gdb_byte *valbuf)
std::vector< CORE_ADDR > alpha_software_single_step(struct regcache *regcache)
static CORE_ADDR alpha_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
static const int subq_function
static int alpha_return_in_memory_always(struct type *type)
static int fp_register_sign_bit(LONGEST reg)
static struct alpha_sigtramp_unwind_cache * alpha_sigtramp_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache)
static int alpha_register_to_value(frame_info_ptr frame, int regnum, struct type *valtype, gdb_byte *out, int *optimizedp, int *unavailablep)
static const int stl_c_opcode
static const int br_opcode
#define OPR_HAS_IMMEDIATE(insn)
static int heuristic_fence_post
static int alpha_cannot_store_register(struct gdbarch *gdbarch, int regno)
static const int stq_c_opcode
static const int subq_opcode
static void reinit_frame_cache_sfunc(const char *args, int from_tty, struct cmd_list_element *c)
static int alpha_cannot_fetch_register(struct gdbarch *gdbarch, int regno)
static void alpha_lds(struct gdbarch *gdbarch, void *out, const void *in)
static const struct frame_unwind alpha_heuristic_frame_unwind
static std::vector< CORE_ADDR > alpha_deal_with_atomic_sequence(struct gdbarch *gdbarch, CORE_ADDR pc)
static enum return_value_convention alpha_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static void alpha_heuristic_analyze_probing_loop(struct gdbarch *gdbarch, CORE_ADDR *pc, int *frame_size)
static struct gdbarch * alpha_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
#define ALPHA_UNIQUE_REGNUM
#define ALPHA_FPA0_REGNUM
#define ALPHA_REGISTER_SIZE
#define ALPHA_NUM_ARG_REGS
CORE_ADDR alpha_after_prologue(CORE_ADDR pc)
#define ALPHA_FPCR_REGNUM
#define ALPHA_GCC_FP_REGNUM
#define ALPHA_ZERO_REGNUM
static std::vector< const char * > arches
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
#define BP_MANIPULATION(BREAK_INSN)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
enum register_status cooked_read(int regnum, gdb_byte *buf)
void raw_collect(int regnum, void *buf) const override
void raw_supply(int regnum, const void *buf) override
void cooked_write(int regnum, const gdb_byte *buf)
struct cmd_list_element * showlist
struct cmd_list_element * setlist
set_show_commands add_setshow_zinteger_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ RETURN_VALUE_ABI_RETURNS_ADDRESS
@ RETURN_VALUE_REGISTER_CONVENTION
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
const struct frame_base * dwarf2_frame_base_sniffer(frame_info_ptr this_frame)
void frame_base_append_sniffer(struct gdbarch *gdbarch, frame_base_sniffer_ftype *sniffer)
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
struct value * frame_unwind_got_memory(frame_info_ptr frame, int regnum, CORE_ADDR addr)
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)
struct value * get_frame_register_value(frame_info_ptr frame, int regnum)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
void reinit_frame_cache(void)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
ULONGEST get_frame_memory_unsigned(frame_info_ptr this_frame, CORE_ADDR addr, int len)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
void put_frame_register(frame_info_ptr frame, int regnum, const gdb_byte *buf)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
void set_gdbarch_register_to_value(struct gdbarch *gdbarch, gdbarch_register_to_value_ftype *register_to_value)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void set_gdbarch_value_to_register(struct gdbarch *gdbarch, gdbarch_value_to_register_ftype *value_to_register)
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step)
void set_gdbarch_get_longjmp_target(struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_wchar_bit(struct gdbarch *gdbarch, int wchar_bit)
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_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_decr_pc_after_break(struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break)
void set_gdbarch_wchar_signed(struct gdbarch *gdbarch, int wchar_signed)
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_cannot_step_breakpoint(struct gdbarch *gdbarch, int cannot_step_breakpoint)
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_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_float_bit(struct gdbarch *gdbarch, int float_bit)
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
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_convert_register_p(struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype *convert_register_p)
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
void set_gdbarch_cannot_store_register(struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype *cannot_store_register)
void set_gdbarch_cannot_fetch_register(struct gdbarch *gdbarch, gdbarch_cannot_fetch_register_ftype *cannot_fetch_register)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
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_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep_base *tdep)
function_call_return_method
struct type * lookup_pointer_type(struct type *type)
struct type * check_typedef(struct type *type)
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type, struct type **function_type)
struct inferior * current_inferior(void)
CORE_ADDR find_solib_trampoline_target(frame_info_ptr frame, CORE_ADDR pc)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
int register_size(struct gdbarch *gdbarch, int regnum)
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
LONGEST regcache_raw_get_signed(struct regcache *regcache, int regnum)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
const reggroup *const general_reggroup
const reggroup *const system_reggroup
const reggroup *const float_reggroup
const reggroup *const save_reggroup
const reggroup *const all_reggroup
const reggroup *const restore_reggroup
void(* func)(remote_target *remote, char *)
CORE_ADDR(* sigcontext_addr)(frame_info_ptr)
int(* pc_in_sigtramp)(struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
LONGEST(* dynamic_sigtramp_offset)(struct gdbarch *, CORE_ADDR)
int(* return_in_memory)(struct type *type)
trad_frame_saved_reg * saved_regs
CORE_ADDR sigcontext_addr
struct type * builtin_double
struct type * builtin_func_ptr
struct type * builtin_data_ptr
struct type * builtin_int64
struct type * builtin_int32
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void gdb_printf(struct ui_file *stream, const char *format,...)
struct value * value_cast(struct type *type, struct value *arg2)
struct type * value_type(const struct value *value)
int value_entirely_available(struct value *value)
gdb::array_view< const gdb_byte > value_contents_all(struct value *value)
gdb::array_view< const gdb_byte > value_contents(struct value *value)
int value_optimized_out(struct value *value)
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
value_ref_ptr release_value(struct value *val)
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)