41#include "opcode/tilegx.h"
43#include "gdbsupport/byte-vector.h"
145 static const char *
const register_names[] =
147 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
148 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
149 "r16",
"r17",
"r18",
"r19",
"r20",
"r21",
"r22",
"r23",
150 "r24",
"r25",
"r26",
"r27",
"r28",
"r29",
"r30",
"r31",
151 "r32",
"r33",
"r34",
"r35",
"r36",
"r37",
"r38",
"r39",
152 "r40",
"r41",
"r42",
"r43",
"r44",
"r45",
"r46",
"r47",
153 "r48",
"r49",
"r50",
"r51",
"r52",
"tp",
"sp",
"lr",
154 "sn",
"idn0",
"idn1",
"udn0",
"udn1",
"udn2",
"udn3",
"zero",
159 return register_names[
regnum];
187 return (t->
code () != TYPE_CODE_STRUCT
188 && t->
code () != TYPE_CODE_UNION
189 && t->
code () != TYPE_CODE_ARRAY);
252 gdb_byte *readbuf,
const gdb_byte *writebuf)
276 struct value *function,
278 CORE_ADDR bp_addr,
int nargs,
281 CORE_ADDR struct_addr)
284 CORE_ADDR stack_dest = sp;
287 int typelen, slacklen;
288 static const gdb_byte four_zero_words[16] = { 0 };
301 typelen = args[i]->enclosing_type ()->length ();
307 val = args[i]->contents ().data ();
324 for (j = nargs - 1; j >= i; j--)
326 const gdb_byte *contents = args[j]->contents ().data ();
328 typelen = args[j]->enclosing_type ()->length ();
329 slacklen = align_up (typelen, 8) - typelen;
330 gdb::byte_vector val (typelen + slacklen);
331 memcpy (val.data (), contents, typelen);
332 memset (val.data () + typelen, 0, slacklen);
335 stack_dest -= typelen + slacklen;
336 write_memory (stack_dest, val.data (), typelen + slacklen);
340 stack_dest = stack_dest - 16;
363 CORE_ADDR start_addr, CORE_ADDR end_addr,
369 CORE_ADDR prolog_end = end_addr;
370 gdb_byte instbuf[32 * TILEGX_BUNDLE_SIZE_IN_BYTES];
371 CORE_ADDR instbuf_start;
372 unsigned int instbuf_size;
375 struct tilegx_decoded_instruction
376 decoded[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
380 new_reverse_frame[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
381 int dest_regs[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
382 int reverse_frame_valid, prolog_done, branch_seen, lr_saved_on_stack_p;
383 LONGEST prev_sp_value;
386 if (start_addr >= end_addr
387 || (start_addr % TILEGX_BUNDLE_ALIGNMENT_IN_BYTES) != 0)
398 lr_saved_on_stack_p = 0;
406 for (next_addr = start_addr;
407 next_addr < end_addr;
408 next_addr += TILEGX_BUNDLE_SIZE_IN_BYTES)
411 if (next_addr - instbuf_start >= instbuf_size)
416 unsigned int size_on_same_page = 4096 - (next_addr & 4095);
418 instbuf_size =
sizeof instbuf;
420 if (instbuf_size > size_on_same_page)
421 instbuf_size = size_on_same_page;
423 instbuf_size = std::min ((CORE_ADDR) instbuf_size,
424 (end_addr - next_addr));
425 instbuf_start = next_addr;
428 {instbuf, instbuf_size});
433 reverse_frame_valid = 0;
438 num_insns = parse_insn_tilegx (bundle, next_addr, decoded);
440 for (i = 0; i < num_insns; i++)
442 struct tilegx_decoded_instruction *this_insn = &decoded[i];
443 long long *operands = this_insn->operand_values;
444 const struct tilegx_opcode *opcode = this_insn->opcode;
446 switch (opcode->mnemonic)
451 && reverse_frame[operands[1]].state
454 LONGEST saved_address = reverse_frame[operands[0]].
value;
455 unsigned saved_register
456 = (unsigned) reverse_frame[operands[1]].
value;
463 lr_saved_on_stack_p = 1;
465 case TILEGX_OPC_ADDI:
466 case TILEGX_OPC_ADDLI:
473 uint64_t hopefully_sp
474 = (unsigned) reverse_frame[operands[1]].
value;
475 short op2_as_short = (short) operands[2];
476 signed char op2_as_char = (
signed char) operands[2];
479 if (opcode->mnemonic == TILEGX_OPC_ADDI)
480 op2_as_short = op2_as_char;
485 new_reverse_frame[i].
value
491 short op2_as_short = (short) operands[2];
492 signed char op2_as_char = (
signed char) operands[2];
495 if (opcode->mnemonic == TILEGX_OPC_ADDI)
496 op2_as_short = op2_as_char;
498 new_reverse_frame[i] = reverse_frame[operands[1]];
500 new_reverse_frame[i].
value += op2_as_short;
504 reverse_frame_valid |= 1 << i;
505 dest_regs[i] = operands[0];
512 new_reverse_frame[i] = reverse_frame[operands[2]];
513 new_reverse_frame[i].
value
514 += reverse_frame[operands[i]].
value;
521 reverse_frame_valid |= 1 << i;
522 dest_regs[i] = operands[0];
524 case TILEGX_OPC_MOVE:
525 new_reverse_frame[i] = reverse_frame[operands[1]];
526 reverse_frame_valid |= 1 << i;
527 dest_regs[i] = operands[0];
529 case TILEGX_OPC_MOVEI:
530 case TILEGX_OPC_MOVELI:
532 new_reverse_frame[i].
value = operands[1];
533 reverse_frame_valid |= 1 << i;
534 dest_regs[i] = operands[0];
540 new_reverse_frame[i] = reverse_frame[operands[1]];
541 new_reverse_frame[i].
value
542 = reverse_frame[operands[1]].
value | operands[2];
544 else if (operands[2] == 0)
547 new_reverse_frame[i] = reverse_frame[operands[1]];
554 reverse_frame_valid |= 1 << i;
555 dest_regs[i] = operands[0];
559 && reverse_frame[operands[1]].
value == 0)
562 new_reverse_frame[i] = reverse_frame[operands[2]];
565 && reverse_frame[operands[2]].
value == 0)
568 new_reverse_frame[i] = reverse_frame[operands[1]];
575 reverse_frame_valid |= 1 << i;
576 dest_regs[i] = operands[0];
583 new_reverse_frame[i] = reverse_frame[operands[1]];
584 new_reverse_frame[i].
value
585 -= reverse_frame[operands[2]].
value;
592 reverse_frame_valid |= 1 << i;
593 dest_regs[i] = operands[0];
596 case TILEGX_OPC_FNOP:
597 case TILEGX_OPC_INFO:
598 case TILEGX_OPC_INFOL:
608 case TILEGX_OPC_BEQZ:
609 case TILEGX_OPC_BEQZT:
610 case TILEGX_OPC_BGEZ:
611 case TILEGX_OPC_BGEZT:
612 case TILEGX_OPC_BGTZ:
613 case TILEGX_OPC_BGTZT:
614 case TILEGX_OPC_BLBC:
615 case TILEGX_OPC_BLBCT:
616 case TILEGX_OPC_BLBS:
617 case TILEGX_OPC_BLBST:
618 case TILEGX_OPC_BLEZ:
619 case TILEGX_OPC_BLEZT:
620 case TILEGX_OPC_BLTZ:
621 case TILEGX_OPC_BLTZT:
622 case TILEGX_OPC_BNEZ:
623 case TILEGX_OPC_BNEZT:
625 case TILEGX_OPC_IRET:
626 case TILEGX_OPC_JALR:
627 case TILEGX_OPC_JALRP:
630 case TILEGX_OPC_SWINT0:
631 case TILEGX_OPC_SWINT1:
632 case TILEGX_OPC_SWINT2:
633 case TILEGX_OPC_SWINT3:
643 for (j = 0; j < opcode->num_operands; j++)
645 if (this_insn->operands[j]->is_dest_reg)
647 dest_regs[i] = operands[j];
649 reverse_frame_valid |= 1 << i;
658 for (i = 0; i < num_insns; i++)
661 if ((reverse_frame_valid & (1 << i))
663 reverse_frame[dest_regs[i]] = new_reverse_frame[i];
666 if (prev_sp_value != 0)
679 if (prolog_done && prolog_end == end_addr)
687 prolog_end = next_addr;
696 if (prolog_end == end_addr && cache)
705 && reverse_frame[i].
value != i)
707 unsigned saved_register = (unsigned) reverse_frame[i].
value;
714 if (lr_saved_on_stack_p)
728 CORE_ADDR func_start, end_pc;
735 CORE_ADDR post_prologue_pc
738 if (post_prologue_pc != 0)
739 return std::max (start_pc, post_prologue_pc);
744 end_pc = start_pc + 8 * TILEGX_BUNDLE_SIZE_IN_BYTES;
746 end_pc = std::min (end_pc, s->
endaddr ());
760 CORE_ADDR func_addr = 0, func_end = 0;
764 CORE_ADDR
addr = func_end - TILEGX_BUNDLE_SIZE_IN_BYTES;
800#define INT_SWINT_1_SIGRETURN (~0)
829 { 0x00, 0x50, 0x48, 0x51, 0xae, 0x44, 0x6a, 0x28 };
840 CORE_ADDR current_pc;
943 arch_size = bfd_get_arch_size (
info.abfd);
1010 tilegx_breakpoint::kind_from_pc);
1012 tilegx_breakpoint::bp_from_kind);
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
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)
enum register_status raw_read(int regnum, gdb_byte *buf)
void raw_write(int regnum, const gdb_byte *buf)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ RETURN_VALUE_REGISTER_CONVENTION
@ RETURN_VALUE_STRUCT_CONVENTION
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
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)
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)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
bool safe_frame_unwind_memory(frame_info_ptr this_frame, CORE_ADDR addr, gdb::array_view< gdb_byte > buffer)
#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)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align)
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc)
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_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_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
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_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_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype *stack_frame_destroyed_p)
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_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)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
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)
function_call_return_method
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
struct obj_section * find_pc_section(CORE_ADDR pc)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
struct type * builtin_func_ptr
struct type * builtin_uint64
CORE_ADDR endaddr() const
trad_frame_saved_reg * saved_regs
void set_realreg(int realreg)
void set_addr(LONGEST addr)
void set_value(LONGEST val)
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static CORE_ADDR tilegx_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
static void tilegx_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
static enum return_value_convention tilegx_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static int tilegx_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int num)
static CORE_ADDR tilegx_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 CORE_ADDR tilegx_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR start_addr, CORE_ADDR end_addr, struct tilegx_frame_cache *cache, frame_info_ptr next_frame)
static int tilegx_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
static const struct frame_base tilegx_frame_base
static const char * tilegx_register_name(struct gdbarch *gdbarch, int regnum)
static const struct tilegx_reverse_regs template_reverse_regs[TILEGX_NUM_PHYS_REGS]
static int tilegx_cannot_reference_register(struct gdbarch *gdbarch, int regno)
#define INT_SWINT_1_SIGRETURN
void _initialize_tilegx_tdep()
static void tilegx_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static void tilegx_write_pc(struct regcache *regcache, CORE_ADDR pc)
constexpr gdb_byte tilegx_break_insn[]
static struct value * tilegx_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static int tilegx_get_longjmp_target(frame_info_ptr frame, CORE_ADDR *pc)
static struct type * tilegx_register_type(struct gdbarch *gdbarch, int regnum)
static CORE_ADDR tilegx_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc)
static const struct frame_unwind tilegx_frame_unwind
static struct gdbarch * tilegx_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static CORE_ADDR tilegx_frame_base_address(frame_info_ptr this_frame, void **this_cache)
static int tilegx_type_is_scalar(struct type *t)
static int tilegx_use_struct_convention(struct type *type)
static void tilegx_store_return_value(struct type *type, struct regcache *regcache, const void *valbuf)
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)