50#define INSN_OPCODE(insn) ((insn & 0xfc000000) >> 26)
53#define MEM_RA(insn) ((insn & 0x03e00000) >> 21)
54#define MEM_RB(insn) ((insn & 0x001f0000) >> 16)
55#define MEM_DISP(insn) \
56 (((insn & 0x8000) == 0) ? (insn & 0xffff) : -((-insn) & 0xffff))
62#define BR_RA(insn) MEM_RA(insn)
68#define OPR_FUNCTION(insn) ((insn & 0xfe0) >> 5)
69#define OPR_HAS_IMMEDIATE(insn) ((insn & 0x1000) == 0x1000)
70#define OPR_RA(insn) MEM_RA(insn)
71#define OPR_RC(insn) ((insn & 0x1f))
72#define OPR_LIT(insn) ((insn & 0x1fe000) >> 13)
88 static const char *
const register_names[] =
90 "v0",
"t0",
"t1",
"t2",
"t3",
"t4",
"t5",
"t6",
91 "t7",
"s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"fp",
92 "a0",
"a1",
"a2",
"a3",
"a4",
"a5",
"t8",
"t9",
93 "t10",
"t11",
"ra",
"t12",
"at",
"gp",
"sp",
"zero",
94 "f0",
"f1",
"f2",
"f3",
"f4",
"f5",
"f6",
"f7",
95 "f8",
"f9",
"f10",
"f11",
"f12",
"f13",
"f14",
"f15",
96 "f16",
"f17",
"f18",
"f19",
"f20",
"f21",
"f22",
"f23",
97 "f24",
"f25",
"f26",
"f27",
"f28",
"f29",
"f30",
"fpcr",
102 return register_names[regno];
185 ULONGEST frac = (mem >> 0) & 0x7fffff;
186 ULONGEST sign = (mem >> 31) & 1;
187 ULONGEST exp_msb = (mem >> 30) & 1;
188 ULONGEST exp_low = (mem >> 23) & 0x7f;
191 exp = (exp_msb << 10) | exp_low;
203 reg = (sign << 63) | (exp << 52) | (frac << 29);
217 mem = ((reg >> 32) & 0xc0000000) | ((reg >> 29) & 0x3fffffff);
237 struct type *valtype, gdb_byte *out,
238 int *optimizedp,
int *unavailablep)
243 gdb_assert (
value != NULL);
247 if (*optimizedp || *unavailablep)
255 gdb_assert (valtype->
length () == 4);
264 struct type *valtype,
const gdb_byte *in)
268 gdb_assert (valtype->
length () == 4);
292 int nargs,
struct value **args, CORE_ADDR sp,
294 CORE_ADDR struct_addr)
301 const gdb_byte *contents;
305 struct alpha_arg *alpha_args = XALLOCAVEC (
struct alpha_arg, nargs);
306 struct alpha_arg *m_arg;
308 int required_arg_regs;
319 for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
321 struct value *arg = args[i];
325 switch (arg_type->
code ())
330 case TYPE_CODE_RANGE:
332 if (arg_type->
length () == 4)
349 if (accumulate_size <
sizeof (arg_reg_buffer)
350 && arg_type->
length () == 4)
357 else if (arg_type->
length () == 16)
360 sp = (sp & -16) - 16;
371 case TYPE_CODE_COMPLEX:
378 if (arg_type->
length () == 32)
381 sp = (sp & -16) - 16;
395 m_arg->len = arg_type->
length ();
396 m_arg->offset = accumulate_size;
397 accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
398 m_arg->contents = arg->
contents ().data ();
403 required_arg_regs = accumulate_size / 8;
408 if (accumulate_size <
sizeof(arg_reg_buffer))
411 accumulate_size -=
sizeof(arg_reg_buffer);
412 sp -= accumulate_size;
418 for (i = nargs; m_arg--, --i >= 0;)
420 const gdb_byte *contents = m_arg->contents;
421 int offset = m_arg->offset;
422 int len = m_arg->len;
425 if (offset <
sizeof(arg_reg_buffer))
427 if (offset + len <=
sizeof(arg_reg_buffer))
429 memcpy (arg_reg_buffer + offset, contents, len);
434 int tlen =
sizeof(arg_reg_buffer) - offset;
435 memcpy (arg_reg_buffer + offset, contents, tlen);
443 write_memory (sp + offset -
sizeof(arg_reg_buffer), contents, len);
447 byte_order, struct_addr);
450 for (i = 0; i < required_arg_regs; i++)
476 switch (valtype->
code ())
479 switch (valtype->
length ())
496 internal_error (_(
"unknown floating point width"));
500 case TYPE_CODE_COMPLEX:
501 switch (valtype->
length ())
519 internal_error (_(
"unknown floating point width"));
536 const gdb_byte *valbuf)
542 switch (valtype->
code ())
545 switch (valtype->
length ())
560 error (_(
"Cannot set a 128-bit long double return value."));
563 internal_error (_(
"unknown floating point width"));
567 case TYPE_CODE_COMPLEX:
568 switch (valtype->
length ())
584 error (_(
"Cannot set a 128-bit long double return value."));
587 internal_error (_(
"unknown floating point width"));
595 if (valtype->
length () == 4)
606 gdb_byte *readbuf,
const gdb_byte *writebuf)
611 if ((
code == TYPE_CODE_STRUCT
612 ||
code == TYPE_CODE_UNION
613 ||
code == TYPE_CODE_ARRAY)
653 CORE_ADDR func_addr, func_end;
659 if (sal.
end < func_end)
694 CORE_ADDR post_prologue_pc;
712 if (post_prologue_pc != 0)
713 return std::max (
pc, post_prologue_pc);
725 if ((inst & 0xffff0000) == 0x27bb0000)
727 if ((inst & 0xffff0000) == 0x23bd0000)
729 if ((inst & 0xffff0000) == 0x23de0000)
731 if ((inst & 0xffe01fff) == 0x43c0153e)
734 if (((inst & 0xfc1f0000) == 0xb41e0000
735 || (inst & 0xfc1f0000) == 0x9c1e0000)
736 && (inst & 0x03e00000) != 0x03e00000)
739 if (inst == 0x47de040f)
741 if (inst == 0x47fe040f)
760static std::vector<CORE_ADDR>
763 CORE_ADDR breaks[2] = {CORE_ADDR_MAX, CORE_ADDR_MAX};
765 CORE_ADDR closing_insn;
769 int last_breakpoint = 0;
770 const int atomic_sequence_length = 16;
771 int bc_insn_count = 0;
780 for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
790 int immediate = (insn & 0x001fffff) << 2;
792 immediate = (immediate ^ 0x400000) - 0x400000;
794 if (bc_insn_count >= 1)
823 && (breaks[1] == breaks[0]
824 || (breaks[1] >=
pc && breaks[1] <= closing_insn)))
827 std::vector<CORE_ADDR> next_pcs;
829 for (index = 0; index <= last_breakpoint; index++)
830 next_pcs.push_back (breaks[index]);
874 void **this_prologue_cache)
878 if (*this_prologue_cache)
882 *this_prologue_cache = info;
915 void **this_prologue_cache,
922 CORE_ADDR stack_addr, code_addr;
925 if (info->sigcontext_addr == 0)
957 void **this_prologue_cache,
int regnum)
963 if (info->sigcontext_addr != 0)
967 info->sigcontext_addr,
regnum);
982 void **this_prologue_cache)
1036 CORE_ADDR last_non_nop = pc;
1038 CORE_ADDR orig_pc = pc;
1053 || fence < tdep->vm_min_address)
1066 return last_non_nop;
1085 static int blurb_printed = 0;
1088 warning (_(
"Hit beginning of text section without finding \
1091 warning (_(
"Hit heuristic-fence-post without finding \
1097This warning occurs if you are debugging a function without any symbols\n\
1098(for example, in a stripped executable). In that case, you may wish to\n\
1099increase the size of the search with the `set heuristic-fence-post' command.\n\
1101Otherwise, you told GDB there was a function where there isn't one, or\n\
1102(more likely) you have encountered a bug in GDB.\n"));
1129 CORE_ADDR cur_pc = *pc;
1130 int cur_frame_size = *frame_size;
1131 int nb_of_iterations, reg_index, reg_probe;
1156 reg_index =
MEM_RA (insn);
1157 nb_of_iterations =
MEM_DISP (insn);
1166 reg_probe =
MEM_RA (insn);
1175 ||
MEM_RB (insn) != reg_probe)
1186 ||
OPR_RA (insn) != reg_index
1187 ||
OPR_RC (insn) != reg_index)
1195 ||
MEM_RA (insn) != reg_probe
1196 ||
MEM_RB (insn) != reg_probe)
1198 cur_frame_size -=
MEM_DISP (insn) * nb_of_iterations;
1205 ||
MEM_RA (insn) != reg_index)
1214 ||
MEM_RB (insn) != reg_probe)
1219 *frame_size = cur_frame_size;
1224 void **this_prologue_cache,
1230 CORE_ADDR limit_pc, cur_pc;
1233 if (*this_prologue_cache)
1237 *this_prologue_cache = info;
1260 if ((word & 0xffff0000) == 0x23de0000)
1266 if (frame_size == 0)
1267 frame_size = (-word) & 0xffff;
1277 else if ((word & 0xfc1f0000) == 0xb41e0000)
1279 reg = (word & 0x03e00000) >> 21;
1288 if (info->saved_regs[reg].is_addr ())
1304 info->saved_regs[reg].set_addr ((word & 0xffff) + 1);
1333 else if ((word & 0xffe0ffff) == 0x6be08001)
1335 else if (word == 0x47de040f)
1337 else if (word == 0x47fe040f)
1347 while (cur_pc < (limit_pc + 80) && cur_pc < (
start_pc + 80))
1351 if ((word & 0xfc1f0000) == 0xb41e0000)
1353 reg = (word & 0x03e00000) >> 21;
1362 else if ((word & 0xffe0ffff) == 0x6be08001)
1379 info->vfp = val + frame_size;
1384 if (info->saved_regs[reg].is_addr ())
1385 info->saved_regs[reg].set_addr (info->saved_regs[reg].addr ()
1401 void **this_prologue_cache,
1412static struct value *
1414 void **this_prologue_cache,
int regnum)
1423 regnum = info->return_reg;
1441 void **this_prologue_cache)
1472 const void *r0_r30,
const void *pc,
const void *unique)
1474 const gdb_byte *regs = (
const gdb_byte *) r0_r30;
1477 for (i = 0; i < 31; ++i)
1478 if (regno == i || regno == -1)
1483 const gdb_byte zero[8] = { 0 };
1497 int regno,
void *r0_r30,
void *pc,
void *unique)
1499 gdb_byte *regs = (gdb_byte *) r0_r30;
1502 for (i = 0; i < 31; ++i)
1503 if (regno == i || regno == -1)
1515 const void *f0_f30,
const void *fpcr)
1517 const gdb_byte *regs = (
const gdb_byte *) f0_f30;
1521 if (regno == i || regno == -1)
1530 int regno,
void *f0_f30,
void *fpcr)
1532 gdb_byte *regs = (gdb_byte *) f0_f30;
1536 if (regno == i || regno == -1)
1552 const LONGEST zero_mask = ((LONGEST) 1 << 63) ^ -1;
1554 return ((reg & zero_mask) == 0);
1563 const LONGEST sign_mask = (LONGEST) 1 << 63;
1565 return ((reg & sign_mask) != 0);
1586 op = (insn >> 26) & 0x3f;
1592 return (regcache_raw_get_unsigned (
regcache, (insn >> 16) & 0x1f) & ~3);
1595 if ((op & 0x30) == 0x30)
1603 offset = (insn & 0x001fffff);
1604 if (offset & 0x00100000)
1605 offset |= 0xffe00000;
1611 regno = (insn >> 21) & 0x1f;
1694std::vector<CORE_ADDR>
1701 std::vector<CORE_ADDR> next_pcs
1703 if (!next_pcs.empty ())
1788 alpha_breakpoint::kind_from_pc);
1790 alpha_breakpoint::bp_from_kind);
1803 if (tdep->
jb_pc >= 0)
1837Set the distance searched for the start of a function."), _(
"\
1838Show the distance searched for the start of a function."), _(
"\
1839If you are debugging a stripped executable, GDB needs to search through the\n\
1840program for the start of a function. This command sets the distance of the\n\
1841search. 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
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_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, gdbarch_tdep_up tdep)
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
function_call_return_method
struct type * lookup_pointer_type(struct type *type)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
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
gdb::array_view< const gdb_byte > contents_all()
gdb::array_view< const gdb_byte > contents()
bool entirely_available()
struct type * type() const
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 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)