X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fmoxie-tdep.c;h=9154d488499a77d7219f9c034216d9d1c8a022bc;hb=96ba371ad40c067fdf5a95747d1c5f3984b96a16;hp=5e5c19bc38225383763e770fc7a255248bdc8345;hpb=325fac504a327de9c46a4e5cf9c88ece9d9d7701;p=binutils-gdb.git diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c index 5e5c19bc382..9154d488499 100644 --- a/gdb/moxie-tdep.c +++ b/gdb/moxie-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for Moxie. - Copyright (C) 2009-2016 Free Software Foundation, Inc. + Copyright (C) 2009-2023 Free Software Foundation, Inc. This file is part of GDB. @@ -41,10 +41,6 @@ #include "moxie-tdep.h" #include -/* Local functions. */ - -extern void _initialize_moxie_tdep (void); - /* Use an invalid address value as 'not available' marker. */ enum { REG_UNAVAIL = (CORE_ADDR) -1 }; @@ -68,21 +64,13 @@ moxie_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp) return sp & ~1; } -/* Implement the "breakpoint_from_pc" gdbarch method. */ +constexpr gdb_byte moxie_break_insn[] = { 0x35, 0x00 }; -static const unsigned char * -moxie_breakpoint_from_pc (struct gdbarch *gdbarch, - CORE_ADDR *pcptr, int *lenptr) -{ - static unsigned char breakpoint[] = { 0x35, 0x00 }; - - *lenptr = sizeof (breakpoint); - return breakpoint; -} +typedef BP_MANIPULATION (moxie_break_insn) moxie_breakpoint; /* Moxie register names. */ -char *moxie_register_names[] = { +static const char * const moxie_register_names[] = { "$fp", "$sp", "$r0", "$r1", "$r2", "$r3", "$r4", "$r5", "$r6", "$r7", "$r8", "$r9", "$r10", "$r11", "$r12", @@ -93,10 +81,7 @@ char *moxie_register_names[] = { static const char * moxie_register_name (struct gdbarch *gdbarch, int reg_nr) { - if (reg_nr < 0) - return NULL; - if (reg_nr >= MOXIE_NUM_REGS) - return NULL; + gdb_static_assert (ARRAY_SIZE (moxie_register_names) == MOXIE_NUM_REGS); return moxie_register_names[reg_nr]; } @@ -120,10 +105,10 @@ static void moxie_store_return_value (struct type *type, struct regcache *regcache, const gdb_byte *valbuf) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR regval; - int len = TYPE_LENGTH (type); + int len = type->length (); /* Things always get returned in RET1_REGNUM, RET2_REGNUM. */ regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len, byte_order); @@ -244,7 +229,7 @@ moxie_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol; /* Don't use line number debug info for assembly source files. */ - if (sym && SYMBOL_LANGUAGE (sym) != language_asm) + if (sym && sym->language () != language_asm) { sal = find_pc_line (func_addr, 0); if (sal.end && sal.end < func_end) @@ -279,11 +264,11 @@ struct moxie_unwind_cache LONGEST r13_offset; int uses_frame; /* Table indicating the location of each and every register. */ - struct trad_frame_saved_reg *saved_regs; + trad_frame_saved_reg *saved_regs; }; /* Read an unsigned integer from the inferior, and adjust - endianess. */ + endianness. */ static ULONGEST moxie_process_readu (CORE_ADDR addr, gdb_byte *buf, int length, enum bfd_endian byte_order) @@ -291,9 +276,10 @@ moxie_process_readu (CORE_ADDR addr, gdb_byte *buf, if (target_read_memory (addr, buf, length)) { if (record_debug) - printf_unfiltered (_("Process record: error reading memory at " - "addr 0x%s len = %d.\n"), - paddress (target_gdbarch (), addr), length); + gdb_printf (gdb_stderr, + _("Process record: error reading memory at " + "addr 0x%s len = %d.\n"), + paddress (target_gdbarch (), addr), length); return -1; } @@ -307,20 +293,19 @@ moxie_process_readu (CORE_ADDR addr, gdb_byte *buf, /* Insert a single step breakpoint. */ -static int -moxie_software_single_step (struct frame_info *frame) +static std::vector +moxie_software_single_step (struct regcache *regcache) { - struct gdbarch *gdbarch = get_frame_arch (frame); - struct address_space *aspace = get_frame_address_space (frame); + struct gdbarch *gdbarch = regcache->arch (); CORE_ADDR addr; gdb_byte buf[4]; uint16_t inst; uint32_t tmpu32; ULONGEST fp; enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - struct regcache *regcache = get_current_regcache (); + std::vector next_pcs; - addr = get_frame_pc (frame); + addr = regcache_read_pc (regcache); inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order); @@ -346,8 +331,8 @@ moxie_software_single_step (struct frame_info *frame) case 0x09: /* bleu */ /* Insert breaks on both branches, because we can't currently tell which way things will go. */ - insert_single_step_breakpoint (gdbarch, aspace, addr + 2); - insert_single_step_breakpoint (gdbarch, aspace, addr + 2 + INST2OFFSET(inst)); + next_pcs.push_back (addr + 2); + next_pcs.push_back (addr + 2 + INST2OFFSET(inst)); break; default: { @@ -359,7 +344,7 @@ moxie_software_single_step (struct frame_info *frame) else { /* This is a Form 2 instruction. They are all 16 bits. */ - insert_single_step_breakpoint (gdbarch, aspace, addr + 2); + next_pcs.push_back (addr + 2); } } else @@ -406,7 +391,7 @@ moxie_software_single_step (struct frame_info *frame) case 0x32: /* udiv.l */ case 0x33: /* mod.l */ case 0x34: /* umod.l */ - insert_single_step_breakpoint (gdbarch, aspace, addr + 2); + next_pcs.push_back (addr + 2); break; /* 32-bit instructions. */ @@ -416,7 +401,7 @@ moxie_software_single_step (struct frame_info *frame) case 0x37: /* sto.b */ case 0x38: /* ldo.s */ case 0x39: /* sto.s */ - insert_single_step_breakpoint (gdbarch, aspace, addr + 4); + next_pcs.push_back (addr + 4); break; /* 48-bit instructions. */ @@ -429,32 +414,25 @@ moxie_software_single_step (struct frame_info *frame) case 0x20: /* ldi.s (immediate) */ case 0x22: /* lda.s */ case 0x24: /* sta.s */ - insert_single_step_breakpoint (gdbarch, aspace, addr + 6); + next_pcs.push_back (addr + 6); break; /* Control flow instructions. */ case 0x03: /* jsra */ case 0x1a: /* jmpa */ - insert_single_step_breakpoint (gdbarch, aspace, - moxie_process_readu (addr + 2, - buf, 4, - byte_order)); + next_pcs.push_back (moxie_process_readu (addr + 2, buf, 4, + byte_order)); break; case 0x04: /* ret */ regcache_cooked_read_unsigned (regcache, MOXIE_FP_REGNUM, &fp); - insert_single_step_breakpoint (gdbarch, aspace, - moxie_process_readu (fp + 4, - buf, 4, - byte_order)); + next_pcs.push_back (moxie_process_readu (fp + 4, buf, 4, byte_order)); break; case 0x19: /* jsr */ case 0x25: /* jmp */ - regcache_raw_read (regcache, - (inst >> 4) & 0xf, (gdb_byte *) & tmpu32); - insert_single_step_breakpoint (gdbarch, aspace, - tmpu32); + regcache->raw_read ((inst >> 4) & 0xf, (gdb_byte *) & tmpu32); + next_pcs.push_back (tmpu32); break; case 0x30: /* swi */ @@ -464,34 +442,7 @@ moxie_software_single_step (struct frame_info *frame) } } - return 1; -} - -/* Implement the "read_pc" gdbarch method. */ - -static CORE_ADDR -moxie_read_pc (struct regcache *regcache) -{ - ULONGEST pc; - - regcache_cooked_read_unsigned (regcache, MOXIE_PC_REGNUM, &pc); - return pc; -} - -/* Implement the "write_pc" gdbarch method. */ - -static void -moxie_write_pc (struct regcache *regcache, CORE_ADDR val) -{ - regcache_cooked_write_unsigned (regcache, MOXIE_PC_REGNUM, val); -} - -/* Implement the "unwind_sp" gdbarch method. */ - -static CORE_ADDR -moxie_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) -{ - return frame_unwind_register_unsigned (next_frame, MOXIE_SP_REGNUM); + return next_pcs; } /* Given a return value in `regbuf' with a type `valtype', @@ -501,9 +452,9 @@ static void moxie_extract_return_value (struct type *type, struct regcache *regcache, gdb_byte *dst) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - int len = TYPE_LENGTH (type); + int len = type->length (); ULONGEST tmp; /* By using store_unsigned_integer we avoid having to do @@ -527,7 +478,7 @@ moxie_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { - if (TYPE_LENGTH (valtype) > 8) + if (valtype->length () > 8) return RETURN_VALUE_STRUCT_CONVENTION; else { @@ -562,7 +513,7 @@ moxie_alloc_frame_cache (void) /* Populate a moxie_frame_cache object for this_frame. */ static struct moxie_frame_cache * -moxie_frame_cache (struct frame_info *this_frame, void **this_cache) +moxie_frame_cache (frame_info_ptr this_frame, void **this_cache) { struct moxie_frame_cache *cache; CORE_ADDR current_pc; @@ -595,19 +546,11 @@ moxie_frame_cache (struct frame_info *this_frame, void **this_cache) return cache; } -/* Implement the "unwind_pc" gdbarch method. */ - -static CORE_ADDR -moxie_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) -{ - return frame_unwind_register_unsigned (next_frame, MOXIE_PC_REGNUM); -} - /* Given a GDB frame, determine the address of the calling function's frame. This will be used to create a new GDB frame struct. */ static void -moxie_frame_this_id (struct frame_info *this_frame, +moxie_frame_this_id (frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id) { struct moxie_frame_cache *cache = moxie_frame_cache (this_frame, @@ -623,7 +566,7 @@ moxie_frame_this_id (struct frame_info *this_frame, /* Get the value of register regnum in the previous stack frame. */ static struct value * -moxie_frame_prev_register (struct frame_info *this_frame, +moxie_frame_prev_register (frame_info_ptr this_frame, void **this_prologue_cache, int regnum) { struct moxie_frame_cache *cache = moxie_frame_cache (this_frame, @@ -642,6 +585,7 @@ moxie_frame_prev_register (struct frame_info *this_frame, } static const struct frame_unwind moxie_frame_unwind = { + "moxie prologue", NORMAL_FRAME, default_frame_unwind_stop_reason, moxie_frame_this_id, @@ -653,7 +597,7 @@ static const struct frame_unwind moxie_frame_unwind = { /* Return the base address of this_frame. */ static CORE_ADDR -moxie_frame_base_address (struct frame_info *this_frame, void **this_cache) +moxie_frame_base_address (frame_info_ptr this_frame, void **this_cache) { struct moxie_frame_cache *cache = moxie_frame_cache (this_frame, this_cache); @@ -668,14 +612,6 @@ static const struct frame_base moxie_frame_base = { moxie_frame_base_address }; -static struct frame_id -moxie_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) -{ - CORE_ADDR sp = get_frame_register_unsigned (this_frame, MOXIE_SP_REGNUM); - - return frame_id_build (sp, get_frame_pc (this_frame)); -} - /* Parse the current instruction and record the values of the registers and memory that will be changed in current instruction to "record_arch_list". Return -1 if something wrong. */ @@ -690,9 +626,9 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); if (record_debug > 1) - fprintf_unfiltered (gdb_stdlog, "Process record: moxie_process_record " - "addr = 0x%s\n", - paddress (target_gdbarch (), addr)); + gdb_printf (gdb_stdlog, "Process record: moxie_process_record " + "addr = 0x%s\n", + paddress (target_gdbarch (), addr)); inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order); @@ -772,7 +708,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, break; case 0x03: /* jsra */ { - regcache_raw_read (regcache, + regcache->raw_read ( MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); @@ -801,7 +737,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x06: /* push */ { int reg = (inst >> 4) & 0xf; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); if (record_full_arch_list_add_reg (regcache, reg) @@ -843,7 +779,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x0b: /* st.l */ { int reg = (inst >> 4) & 0xf; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); if (record_full_arch_list_add_mem (tmpu32, 4)) @@ -862,7 +798,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, int reg = (inst >> 4) & 0xf; uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2, byte_order)) << 16 ) >> 16; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); tmpu32 += offset; @@ -902,7 +838,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, } case 0x19: /* jsr */ { - regcache_raw_read (regcache, + regcache->raw_read ( MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); @@ -930,7 +866,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x1e: /* st.b */ { int reg = (inst >> 4) & 0xf; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); if (record_full_arch_list_add_mem (tmpu32, 1)) @@ -956,7 +892,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x23: /* st.s */ { int reg = (inst >> 4) & 0xf; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); if (record_full_arch_list_add_mem (tmpu32, 2)) @@ -1016,12 +952,12 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, uint32_t length, ptr; /* Read buffer pointer is in $r1. */ - regcache_raw_read (regcache, 3, (gdb_byte *) & ptr); + regcache->raw_read (3, (gdb_byte *) & ptr); ptr = extract_unsigned_integer ((gdb_byte *) & ptr, 4, byte_order); /* String length is at 0x12($fp). */ - regcache_raw_read (regcache, + regcache->raw_read ( MOXIE_FP_REGNUM, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); @@ -1067,7 +1003,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, int reg = (inst >> 4) & 0xf; uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2, byte_order)) << 16 ) >> 16; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); tmpu32 += offset; @@ -1087,7 +1023,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, int reg = (inst >> 4) & 0xf; uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2, byte_order)) << 16 ) >> 16; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); tmpu32 += offset; @@ -1113,21 +1049,17 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, static struct gdbarch * moxie_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) { - struct gdbarch *gdbarch; - struct gdbarch_tdep *tdep; - /* If there is already a candidate, use it. */ arches = gdbarch_list_lookup_by_info (arches, &info); if (arches != NULL) return arches->gdbarch; /* Allocate space for the new architecture. */ - tdep = XNEW (struct gdbarch_tdep); - gdbarch = gdbarch_alloc (&info, tdep); + gdbarch *gdbarch + = gdbarch_alloc (&info, gdbarch_tdep_up (new moxie_gdbarch_tdep)); - set_gdbarch_read_pc (gdbarch, moxie_read_pc); - set_gdbarch_write_pc (gdbarch, moxie_write_pc); - set_gdbarch_unwind_sp (gdbarch, moxie_unwind_sp); + set_gdbarch_wchar_bit (gdbarch, 32); + set_gdbarch_wchar_signed (gdbarch, 0); set_gdbarch_num_regs (gdbarch, MOXIE_NUM_REGS); set_gdbarch_sp_regnum (gdbarch, MOXIE_SP_REGNUM); @@ -1139,20 +1071,14 @@ moxie_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_skip_prologue (gdbarch, moxie_skip_prologue); set_gdbarch_inner_than (gdbarch, core_addr_lessthan); - set_gdbarch_breakpoint_from_pc (gdbarch, moxie_breakpoint_from_pc); + set_gdbarch_breakpoint_kind_from_pc (gdbarch, + moxie_breakpoint::kind_from_pc); + set_gdbarch_sw_breakpoint_from_kind (gdbarch, + moxie_breakpoint::bp_from_kind); set_gdbarch_frame_align (gdbarch, moxie_frame_align); frame_base_set_default (gdbarch, &moxie_frame_base); - /* Methods for saving / extracting a dummy frame's ID. The ID's - stack address must match the SP value returned by - PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ - set_gdbarch_dummy_id (gdbarch, moxie_dummy_id); - - set_gdbarch_unwind_pc (gdbarch, moxie_unwind_pc); - - set_gdbarch_print_insn (gdbarch, print_insn_moxie); - /* Hook in ABI-specific overrides, if they have been registered. */ gdbarch_init_osabi (info, gdbarch); @@ -1173,8 +1099,9 @@ moxie_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Register this machine's init routine. */ +void _initialize_moxie_tdep (); void -_initialize_moxie_tdep (void) +_initialize_moxie_tdep () { - register_gdbarch_init (bfd_arch_moxie, moxie_gdbarch_init); + gdbarch_register (bfd_arch_moxie, moxie_gdbarch_init); }