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",
104 if (regno >= ARRAY_SIZE(register_names))
106 return register_names[regno];
185 alpha_lds (
struct gdbarch *gdbarch,
void *out,
const void *in)
189 ULONGEST frac = (mem >> 0) & 0x7fffff;
192 ULONGEST exp_low = (mem >> 23) & 0x7f;
195 exp = (exp_msb << 10) | exp_low;
207 reg = (sign << 63) | (exp << 52) | (frac << 29);
215 alpha_sts (
struct gdbarch *gdbarch,
void *out,
const void *in)
221 mem = ((reg >> 32) & 0xc0000000) | ((reg >> 29) & 0x3fffffff);
242 int *optimizedp,
int *unavailablep)
250 in, optimizedp, unavailablep))
256 *optimizedp = *unavailablep = 0;
260 error (
_(
"Cannot retrieve value from floating point register"));
275 error (
_(
"Cannot store value in floating point register"));
301 int accumulate_size = struct_return ? 8 : 0;
308 struct alpha_arg *alpha_args
309 = (
struct alpha_arg *) alloca (nargs *
sizeof (
struct alpha_arg));
310 struct alpha_arg *m_arg;
312 int required_arg_regs;
323 for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
325 struct value *arg = args[i];
353 if (accumulate_size <
sizeof (arg_reg_buffer)
364 sp = (sp & -16) - 16;
385 sp = (sp & -16) - 16;
400 m_arg->offset = accumulate_size;
401 accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
407 required_arg_regs = accumulate_size / 8;
412 if (accumulate_size <
sizeof(arg_reg_buffer))
415 accumulate_size -=
sizeof(arg_reg_buffer);
416 sp -= accumulate_size;
422 for (i = nargs; m_arg--, --i >= 0;)
424 const gdb_byte *contents = m_arg->contents;
425 int offset = m_arg->offset;
426 int len = m_arg->len;
429 if (offset <
sizeof(arg_reg_buffer))
431 if (offset + len <=
sizeof(arg_reg_buffer))
433 memcpy (arg_reg_buffer + offset, contents, len);
438 int tlen =
sizeof(arg_reg_buffer) - offset;
439 memcpy (arg_reg_buffer + offset, contents, tlen);
447 write_memory (sp + offset -
sizeof(arg_reg_buffer), contents, len);
451 byte_order, struct_addr);
454 for (i = 0; i < required_arg_regs; i++)
459 arg_reg_buffer + i*ALPHA_REGISTER_SIZE);
501 _(
"unknown floating point width"));
525 _(
"unknown floating point width"));
566 error (
_(
"Cannot set a 128-bit long double return value."));
570 _(
"unknown floating point width"));
591 error (
_(
"Cannot set a 128-bit long double return value."));
595 _(
"unknown floating point width"));
650 static const gdb_byte break_insn[] = { 0x80, 0, 0, 0 };
652 *len =
sizeof(break_insn);
670 if (sal.
end < func_end)
723 if (post_prologue_pc != 0)
724 return max (pc, post_prologue_pc);
736 if ((inst & 0xffff0000) == 0x27bb0000)
738 if ((inst & 0xffff0000) == 0x23bd0000)
740 if ((inst & 0xffff0000) == 0x23de0000)
742 if ((inst & 0xffe01fff) == 0x43c0153e)
745 if (((inst & 0xfc1f0000) == 0xb41e0000
746 || (inst & 0xfc1f0000) == 0x9c1e0000)
747 && (inst & 0x03e00000) != 0x03e00000)
750 if (inst == 0x47de040f)
752 if (inst == 0x47fe040f)
783 int last_breakpoint = 0;
784 const int atomic_sequence_length = 16;
785 int bc_insn_count = 0;
794 for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
804 int immediate = (insn & 0x001fffff) << 2;
806 immediate = (immediate ^ 0x400000) - 0x400000;
808 if (bc_insn_count >= 1)
837 && (breaks[1] == breaks[0]
838 || (breaks[1] >= pc && breaks[1] <= closing_insn)))
842 for (index = 0; index <= last_breakpoint; index++)
887 void **this_prologue_cache)
892 if (*this_prologue_cache)
893 return *this_prologue_cache;
896 *this_prologue_cache = info;
913 if (regnum >= 0 && regnum < 32)
928 void **this_prologue_cache,
968 static struct value *
970 void **this_prologue_cache,
int regnum)
995 void **this_prologue_cache)
1014 if (
gdbarch_tdep (gdbarch)->pc_in_sigtramp (gdbarch, pc, name))
1061 if (heuristic_fence_post == -1
1062 || fence < tdep->vm_min_address)
1075 return last_non_nop;
1094 static int blurb_printed = 0;
1097 warning (
_(
"Hit beginning of text section without finding \
1098 enclosing function for address %s"),
paddress (gdbarch, orig_pc));
1100 warning (
_(
"Hit heuristic-fence-post without finding \
1101 enclosing function for address %s"),
paddress (gdbarch, orig_pc));
1106 This warning occurs if you are debugging a function without any symbols\n\
1107 (for example, in a stripped executable). In that case, you may wish to\n\
1108 increase the size of the search with the `set heuristic-fence-post' command.\n\
1110 Otherwise, you told GDB there was a function where there isn't one, or\n\
1111 (more likely) you have encountered a bug in GDB.\n"));
1139 int cur_frame_size = *frame_size;
1140 int nb_of_iterations, reg_index, reg_probe;
1165 reg_index =
MEM_RA (insn);
1166 nb_of_iterations =
MEM_DISP (insn);
1175 reg_probe =
MEM_RA (insn);
1184 ||
MEM_RB (insn) != reg_probe)
1195 ||
OPR_RA (insn) != reg_index
1196 ||
OPR_RC (insn) != reg_index)
1204 ||
MEM_RA (insn) != reg_probe
1205 ||
MEM_RB (insn) != reg_probe)
1207 cur_frame_size -=
MEM_DISP (insn) * nb_of_iterations;
1214 ||
MEM_RA (insn) != reg_index)
1223 ||
MEM_RB (insn) != reg_probe)
1228 *frame_size = cur_frame_size;
1233 void **this_prologue_cache,
1242 if (*this_prologue_cache)
1243 return *this_prologue_cache;
1246 *this_prologue_cache = info;
1262 if (start_pc + 200 < limit_pc)
1263 limit_pc = start_pc + 200;
1269 if ((word & 0xffff0000) == 0x23de0000)
1275 if (frame_size == 0)
1276 frame_size = (-
word) & 0xffff;
1286 else if ((word & 0xfc1f0000) == 0xb41e0000)
1288 reg = (word & 0x03e00000) >> 21;
1335 if (return_reg == -1
1336 && cur_pc < (start_pc + 80)
1342 else if ((word & 0xffe0ffff) == 0x6be08001)
1343 return_reg = (word >> 16) & 0x1f;
1344 else if (word == 0x47de040f)
1346 else if (word == 0x47fe040f)
1354 if (return_reg == -1)
1356 while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80))
1360 if ((word & 0xfc1f0000) == 0xb41e0000)
1362 reg = (word & 0x03e00000) >> 21;
1371 else if ((word & 0xffe0ffff) == 0x6be08001)
1373 return_reg = (word >> 16) & 0x1f;
1383 if (return_reg == -1)
1388 info->
vfp = val + frame_size;
1409 void **this_prologue_cache,
1420 static struct value *
1422 void **this_prologue_cache,
int regnum)
1447 void **this_prologue_cache)
1459 alpha_heuristic_frame_base_address
1500 const void *r0_r30,
const void *pc,
const void *
unique)
1505 for (i = 0; i < 31; ++i)
1506 if (regno == i || regno == -1)
1525 int regno,
void *r0_r30,
void *pc,
void *
unique)
1530 for (i = 0; i < 31; ++i)
1531 if (regno == i || regno == -1)
1543 const void *f0_f30,
const void *fpcr)
1549 if (regno == i || regno == -1)
1551 regs + (i - ALPHA_FP0_REGNUM) * 8);
1559 int regno,
void *f0_f30,
void *fpcr)
1565 if (regno == i || regno == -1)
1567 regs + (i - ALPHA_FP0_REGNUM) * 8);
1584 return ((reg & zero_mask) == 0);
1595 return ((reg & sign_mask) != 0);
1616 op = (insn >> 26) & 0x3f;
1625 if ((op & 0x30) == 0x30)
1633 offset = (insn & 0x001fffff);
1634 if (offset & 0x00100000)
1635 offset |= 0xffe00000;
1641 regno = (insn >> 21) & 0x1f;
1746 static struct gdbarch *
1750 struct gdbarch *gdbarch;
1837 if (tdep->
jb_pc >= 0)
1873 Set the distance searched for the start of a function."),
_(
"\
1874 Show the distance searched for the start of a function."),
_(
"\
1875 If you are debugging a stripped executable, GDB needs to search through the\n\
1876 program for the start of a function. This command sets the distance of the\n\
1877 search. The only need to set it is when debugging a stripped executable."),
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
void set_gdbarch_cannot_fetch_register(struct gdbarch *gdbarch, gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
void set_gdbarch_value_to_register(struct gdbarch *gdbarch, gdbarch_value_to_register_ftype value_to_register)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
#define ALPHA_NUM_ARG_REGS
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
void set_gdbarch_get_longjmp_target(struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype get_longjmp_target)
CORE_ADDR sigcontext_addr
static void alpha_extract_return_value(struct type *valtype, struct regcache *regcache, gdb_byte *valbuf)
struct type * builtin_func_ptr
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
CORE_ADDR get_frame_pc(struct frame_info *frame)
void 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_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
void alpha_supply_int_regs(struct regcache *regcache, int regno, const void *r0_r30, const void *pc, const void *unique)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
void alpha_fill_int_regs(const struct regcache *regcache, int regno, void *r0_r30, void *pc, void *unique)
int(* return_in_memory)(struct type *type)
struct value * trad_frame_get_prev_register(struct frame_info *this_frame, struct trad_frame_saved_reg this_saved_regs[], int regnum)
static struct gdbarch * alpha_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
int trad_frame_addr_p(struct trad_frame_saved_reg this_saved_regs[], int regnum)
static int alpha_return_in_memory_always(struct type *type)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
LONGEST(* dynamic_sigtramp_offset)(struct gdbarch *, CORE_ADDR)
static int alpha_cannot_fetch_register(struct gdbarch *gdbarch, int regno)
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
static int alpha_deal_with_atomic_sequence(struct frame_info *frame)
void warning(const char *fmt,...)
void trad_frame_set_value(struct trad_frame_saved_reg this_saved_regs[], int regnum, LONGEST val)
static struct value * alpha_sigtramp_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
static CORE_ADDR alpha_sigtramp_register_address(struct gdbarch *gdbarch, CORE_ADDR sigcontext_addr, int regnum)
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
void alpha_dwarf2_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
void internal_error(const char *file, int line, const char *fmt,...)
unsigned int alpha_read_insn(struct gdbarch *gdbarch, CORE_ADDR pc)
static CORE_ADDR alpha_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype register_reggroup_p)
#define INSN_OPCODE(insn)
static void alpha_heuristic_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
CORE_ADDR(* sigcontext_addr)(struct frame_info *)
struct trad_frame_saved_reg * saved_regs
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
struct reggroup *const restore_reggroup
struct address_space * get_frame_address_space(struct frame_info *frame)
struct reggroup *const all_reggroup
static const int lda_opcode
ULONGEST get_frame_memory_unsigned(struct frame_info *this_frame, CORE_ADDR addr, int len)
static void alpha_sts(struct gdbarch *gdbarch, void *out, const void *in)
static int heuristic_fence_post
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
static const int stq_opcode
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
struct type * builtin_int32
static struct type * alpha_register_type(struct gdbarch *gdbarch, int regno)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
void printf_filtered(const char *format,...)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
static void alpha_lds(struct gdbarch *gdbarch, void *out, const void *in)
#define ALPHA_UNIQUE_REGNUM
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
static const int bne_opcode
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
struct reggroup *const float_reggroup
static CORE_ADDR alpha_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
struct cmd_list_element * setlist
static void alpha_sigtramp_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
struct type * check_typedef(struct type *type)
const struct frame_base * dwarf2_frame_base_sniffer(struct frame_info *this_frame)
const gdb_byte * value_contents(struct value *value)
struct reggroup *const general_reggroup
static CORE_ADDR alpha_heuristic_proc_start(struct gdbarch *gdbarch, CORE_ADDR pc)
static const gdb_byte * alpha_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
static int alpha_cannot_store_register(struct gdbarch *gdbarch, int regno)
void initialize_file_ftype(void)
void alpha_fill_fp_regs(const struct regcache *regcache, int regno, void *f0_f30, void *fpcr)
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
CORE_ADDR find_solib_trampoline_target(struct frame_info *frame, CORE_ADDR pc)
static CORE_ADDR alpha_next_pc(struct frame_info *frame, CORE_ADDR pc)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
struct reggroup *const system_reggroup
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
void set_gdbarch_decr_pc_after_break(struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
struct cmd_list_element * showlist
struct inferior_control_state control
static int alpha_sigtramp_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
static void reinit_frame_cache_sfunc(char *args, int from_tty, struct cmd_list_element *c)
void insert_single_step_breakpoint(struct gdbarch *gdbarch, struct address_space *aspace, CORE_ADDR next_pc)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
#define OPR_FUNCTION(insn)
void set_gdbarch_cannot_store_register(struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype cannot_store_register)
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
LONGEST get_frame_register_signed(struct frame_info *frame, int regnum)
#define ALPHA_GCC_FP_REGNUM
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)
void set_gdbarch_register_to_value(struct gdbarch *gdbarch, gdbarch_register_to_value_ftype register_to_value)
static const int subq_function
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
void set_gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
CORE_ADDR alpha_after_prologue(CORE_ADDR pc)
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
#define ALPHA_FPCR_REGNUM
static struct frame_id alpha_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
static struct alpha_heuristic_unwind_cache * alpha_heuristic_frame_unwind_cache(struct frame_info *this_frame, void **this_prologue_cache, CORE_ADDR start_pc)
struct value * value_cast(struct type *type, struct value *arg2)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
static const int stl_c_opcode
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static struct alpha_sigtramp_unwind_cache * alpha_sigtramp_frame_unwind_cache(struct frame_info *this_frame, void **this_prologue_cache)
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
static void alpha_value_to_register(struct frame_info *frame, int regnum, struct type *valtype, const gdb_byte *in)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
void put_frame_register(struct frame_info *frame, int regnum, const gdb_byte *buf)
#define ALPHA_ZERO_REGNUM
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype software_single_step)
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
int alpha_software_single_step(struct frame_info *frame)
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
#define OPR_HAS_IMMEDIATE(insn)
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
struct type * builtin_double
static const struct frame_unwind alpha_heuristic_frame_unwind
void set_gdbarch_convert_register_p(struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype convert_register_p)
static int alpha_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
#define TYPE_CODE(thistype)
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static int alpha_get_longjmp_target(struct frame_info *frame, CORE_ADDR *pc)
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type)
struct type * builtin_data_ptr
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
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, int struct_return, CORE_ADDR struct_addr)
#define ALPHA_FPA0_REGNUM
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
static void alpha_store_return_value(struct type *valtype, struct regcache *regcache, const gdb_byte *valbuf)
static int * unique(int *b, int *e)
static const int subq_opcode
struct inferior * current_inferior(void)
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
void frame_base_append_sniffer(struct gdbarch *gdbarch, frame_base_sniffer_ftype *sniffer)
int get_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, gdb_byte *myaddr, int *optimizedp, int *unavailablep)
unsigned long long ULONGEST
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
initialize_file_ftype _initialize_alpha_tdep
int register_size(struct gdbarch *gdbarch, int regnum)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
struct type * value_type(const struct value *value)
const struct frame_base * base
struct type * builtin_int64
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
void set_gdbarch_cannot_step_breakpoint(struct gdbarch *gdbarch, int cannot_step_breakpoint)
static int fp_register_sign_bit(LONGEST reg)
struct reggroup *const save_reggroup
#define TYPE_LENGTH(thistype)
static const int br_opcode
static CORE_ADDR alpha_heuristic_frame_base_address(struct frame_info *this_frame, void **this_prologue_cache)
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
static const int stq_c_opcode
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
void reinit_frame_cache(void)
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
void alpha_supply_fp_regs(struct regcache *regcache, int regno, const void *f0_f30, const void *fpcr)
#define ALPHA_REGISTER_SIZE
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
static const int ldl_l_opcode
enum bfd_endian byte_order
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
CORE_ADDR get_frame_func(struct frame_info *this_frame)
void error(const char *fmt,...)
static int fp_register_zero_p(LONGEST reg)
static const int ldq_l_opcode
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
static struct value * alpha_heuristic_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
static int alpha_register_to_value(struct frame_info *frame, int regnum, struct type *valtype, gdb_byte *out, int *optimizedp, int *unavailablep)
struct type * lookup_pointer_type(struct type *type)
static const char * alpha_register_name(struct gdbarch *gdbarch, int regno)
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
static int alpha_convert_register_p(struct gdbarch *gdbarch, int regno, struct type *type)
const ULONGEST const LONGEST len
static void alpha_heuristic_analyze_probing_loop(struct gdbarch *gdbarch, CORE_ADDR *pc, int *frame_size)