mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-30 21:44:19 +08:00
870f88f755
gdb/ChangeLog: 2016-05-07 Trevor Saunders <tbsaunde+binutils@tbsaunde.org> * aarch64-linux-tdep.c (aarch64_linux_sigframe_init): Remove unused variables. * aarch64-tdep.c (aarch64_skip_prologue): Likewise. (aarch64_scan_prologue): Likewise. (aarch64_prologue_prev_register): Likewise. (aarch64_dwarf2_prev_register): Likewise. (pass_in_v): Likewise. (aarch64_push_dummy_call): Likewise. (aarch64_breakpoint_from_pc): Likewise. (aarch64_return_in_memory): Likewise. (aarch64_return_value): Likewise. (aarch64_displaced_step_b_cond): Likewise. (aarch64_displaced_step_cb): Likewise. (aarch64_displaced_step_tb): Likewise. (aarch64_gdbarch_init): Likewise. (aarch64_process_record): Likewise. * alpha-mdebug-tdep.c (alpha_mdebug_init_abi): Likewise. * alpha-tdep.c (_initialize_alpha_tdep): Likewise. * amd64-dicos-tdep.c (amd64_dicos_init_abi): Likewise. * amd64-linux-tdep.c (amd64_dtrace_parse_probe_argument): Likewise. * amd64-tdep.c (fixup_riprel): Likewise. * amd64-windows-tdep.c (amd64_windows_frame_decode_epilogue): Likewise. (amd64_windows_frame_decode_insns): Likewise. (amd64_windows_frame_cache): Likewise. (amd64_windows_frame_prev_register): Likewise. (amd64_windows_frame_this_id): Likewise. (amd64_windows_init_abi): Likewise. * arm-linux-tdep.c (arm_linux_get_syscall_number): Likewise. (arm_linux_get_next_pcs_syscall_next_pc): Likewise. * arm-symbian-tdep.c (arm_symbian_init_abi): Likewise. * arm-tdep.c (arm_make_epilogue_frame_cache): Likewise. (arm_epilogue_frame_prev_register): Likewise. (arm_record_vdata_transfer_insn): Likewise. (arm_record_exreg_ld_st_insn): Likewise. * auto-load.c (execute_script_contents): Likewise. (print_scripts): Likewise. * avr-tdep.c (avr_frame_prev_register): Likewise. (avr_push_dummy_call): Likewise. * bfin-linux-tdep.c (bfin_linux_sigframe_init): Likewise. * bfin-tdep.c (bfin_gdbarch_init): Likewise. * blockframe.c (find_pc_partial_function_gnu_ifunc): Likewise. * break-catch-throw.c (fetch_probe_arguments): Likewise. * breakpoint.c (breakpoint_xfer_memory): Likewise. (breakpoint_init_inferior): Likewise. (breakpoint_inserted_here_p): Likewise. (software_breakpoint_inserted_here_p): Likewise. (hardware_breakpoint_inserted_here_p): Likewise. (bpstat_what): Likewise. (break_range_command): Likewise. (save_breakpoints): Likewise. * coffread.c (coff_symfile_read): Likewise. * cris-tdep.c (cris_push_dummy_call): Likewise. (cris_scan_prologue): Likewise. (cris_register_size): Likewise. (_initialize_cris_tdep): Likewise. * d-exp.y: Likewise. * dbxread.c (dbx_read_symtab): Likewise. (process_one_symbol): Likewise. (coffstab_build_psymtabs): Likewise. (elfstab_build_psymtabs): Likewise. * dicos-tdep.c (dicos_init_abi): Likewise. * disasm.c (do_mixed_source_and_assembly): Likewise. (gdb_disassembly): Likewise. * dtrace-probe.c (dtrace_process_dof): Likewise. * dwarf2read.c (error_check_comp_unit_head): Likewise. (build_type_psymtabs_1): Likewise. (skip_one_die): Likewise. (process_imported_unit_die): Likewise. (dwarf2_physname): Likewise. (read_file_scope): Likewise. (setup_type_unit_groups): Likewise. (create_dwo_cu_reader): Likewise. (create_dwo_cu): Likewise. (create_dwo_unit_in_dwp_v1): Likewise. (create_dwo_unit_in_dwp_v2): Likewise. (lookup_dwo_unit_in_dwp): Likewise. (free_dwo_file): Likewise. (check_producer): Likewise. (dwarf2_add_typedef): Likewise. (dwarf2_add_member_fn): Likewise. (read_unsigned_leb128): Likewise. (read_signed_leb128): Likewise. (dwarf2_const_value): Likewise. (follow_die_sig_1): Likewise. (dwarf_decode_macro_bytes): Likewise. * extension.c (restore_active_ext_lang): Likewise. * frv-linux-tdep.c (frv_linux_sigtramp_frame_cache): Likewise. * ft32-tdep.c (ft32_analyze_prologue): Likewise. * gdbtypes.c (lookup_typename): Likewise. (resolve_dynamic_range): Likewise. (check_typedef): Likewise. * h8300-tdep.c (h8300_is_argument_spill): Likewise. (h8300_gdbarch_init): Likewise. * hppa-tdep.c (hppa32_push_dummy_call): Likewise. (hppa_frame_this_id): Likewise. (_initialize_hppa_tdep): Likewise. * hppanbsd-tdep.c (hppanbsd_sigtramp_cache_init): Likewise. * hppaobsd-tdep.c (hppaobsd_supply_fpregset): Likewise. * i386-dicos-tdep.c (i386_dicos_init_abi): Likewise. * i386-tdep.c (i386_bnd_type): Likewise. (i386_gdbarch_init): Likewise. (i386_mpx_bd_base): Likewise. * i386nbsd-tdep.c (i386nbsd_sigtramp_cache_init): Likewise. * i386obsd-tdep.c (i386obsd_elf_init_abi): Likewise. * ia64-tdep.c (examine_prologue): Likewise. (ia64_frame_cache): Likewise. (ia64_push_dummy_call): Likewise. * infcmd.c (finish_command_fsm_async_reply_reason): Likewise. (default_print_one_register_info): Likewise. * infrun.c (infrun_thread_ptid_changed): Likewise. (thread_still_needs_step_over): Likewise. (stop_all_threads): Likewise. (restart_threads): Likewise. (keep_going_stepped_thread): Likewise. * iq2000-tdep.c (iq2000_scan_prologue): Likewise. * language.c (language_init_primitive_type_symbols): Likewise. * linespec.c (add_sal_to_sals): Likewise. * linux-nat.c (status_callback): Likewise. (kill_unfollowed_fork_children): Likewise. (linux_nat_kill): Likewise. * linux-tdep.c (linux_fill_prpsinfo): Likewise. * linux-thread-db.c (thread_db_notice_clone): Likewise. (record_thread): Likewise. * location.c (string_to_event_location_basic): Likewise. * m32c-tdep.c (m32c_prev_register): Likewise. * m32r-linux-tdep.c (m32r_linux_init_abi): Likewise. * m32r-tdep.c (decode_prologue): Likewise. * m68klinux-tdep.c (m68k_linux_sigtramp_frame_cache): Likewise. * machoread.c (macho_symtab_read): Likewise. (macho_symfile_read): Likewise. (macho_symfile_offsets): Likewise. * maint.c (set_per_command_cmd): Likewise. * mi/mi-cmd-stack.c (mi_cmd_stack_list_locals): Likewise. (mi_cmd_stack_list_variables): Likewise. * mi/mi-main.c (mi_cmd_exec_run): Likewise. (output_register): Likewise. (mi_cmd_execute): Likewise. (mi_cmd_trace_define_variable): Likewise. (print_variable_or_computed): Likewise. * minsyms.c (prim_record_minimal_symbol_full): Likewise. * mn10300-tdep.c (mn10300_frame_prev_register): Likewise. * msp430-tdep.c (msp430_pseudo_register_write): Likewise. * mt-tdep.c (mt_registers_info): Likewise. * nios2-tdep.c (nios2_analyze_prologue): Likewise. (nios2_push_dummy_call): Likewise. (nios2_frame_unwind_cache): Likewise. (nios2_stub_frame_cache): Likewise. (nios2_stub_frame_sniffer): Likewise. (nios2_gdbarch_init): Likewise. * ppc-ravenscar-thread.c: Likewise. * ppcfbsd-tdep.c (ppcfbsd_sigtramp_frame_cache): Likewise. * python/py-evts.c (add_new_registry): Likewise. * python/py-finishbreakpoint.c (bpfinishpy_init): Likewise. (bpfinishpy_detect_out_scope_cb): Likewise. * python/py-framefilter.c (py_print_value): Likewise. * python/py-inferior.c (infpy_write_memory): Likewise. * python/py-infevents.c (create_inferior_call_event_object): Likewise. * python/py-infthread.c (thpy_get_ptid): Likewise. * python/py-linetable.c (ltpy_get_pcs_for_line): Likewise. (ltpy_get_all_source_lines): Likewise. (ltpy_is_valid): Likewise. (ltpy_iternext): Likewise. * python/py-symtab.c (symtab_and_line_to_sal_object): Likewise. * python/py-unwind.c (pyuw_object_attribute_to_pointer): Likewise. (unwind_infopy_str): Likewise. * python/py-varobj.c (py_varobj_get_iterator): Likewise. * ravenscar-thread.c (ravenscar_inferior_created): Likewise. * rs6000-aix-tdep.c (rs6000_push_dummy_call): Likewise. * rs6000-lynx178-tdep.c (rs6000_lynx178_push_dummy_call): Likewise. * rs6000-tdep.c (ppc_deal_with_atomic_sequence): Likewise. * s390-linux-tdep.c (s390_supply_tdb_regset): Likewise. (s390_frame_prev_register): Likewise. (s390_dwarf2_frame_init_reg): Likewise. (s390_record_vr): Likewise. (s390_process_record): Likewise. * score-tdep.c (score_push_dummy_call): Likewise. (score3_analyze_prologue): Likewise. * sh-tdep.c (sh_extract_return_value_nofpu): Likewise. * sh64-tdep.c (sh64_analyze_prologue): Likewise. (sh64_push_dummy_call): Likewise. (sh64_extract_return_value): Likewise. (sh64_do_fp_register): Likewise. * solib-aix.c (solib_aix_get_section_offsets): Likewise. * solib-darwin.c (darwin_read_exec_load_addr_from_dyld): Likewise. (darwin_solib_read_all_image_info_addr): Likewise. * solib-dsbt.c (enable_break): Likewise. * solib-frv.c (enable_break2): Likewise. (frv_fdpic_find_canonical_descriptor): Likewise. * solib-svr4.c (svr4_handle_solib_event): Likewise. * sparc-tdep.c (sparc_skip_stack_check): Likewise. * sparc64-linux-tdep.c (sparc64_linux_get_longjmp_target): Likewise. * sparcobsd-tdep.c (sparc32obsd_init_abi): Likewise. * spu-tdep.c (info_spu_dma_cmdlist): Likewise. * stack.c (read_frame_local): Likewise. * symfile.c (symbol_file_add_separate): Likewise. (remove_symbol_file_command): Likewise. * symmisc.c (maintenance_print_one_line_table): Likewise. * symtab.c (symbol_cache_flush): Likewise. (basic_lookup_transparent_type): Likewise. (sort_search_symbols_remove_dups): Likewise. * target.c (target_memory_map): Likewise. (target_detach): Likewise. (target_resume): Likewise. (acquire_fileio_fd): Likewise. (target_store_registers): Likewise. * thread.c (print_thread_info_1): Likewise. * tic6x-tdep.c (tic6x_analyze_prologue): Likewise. * tilegx-linux-tdep.c (tilegx_linux_sigframe_init): Likewise. * tilegx-tdep.c (tilegx_push_dummy_call): Likewise. (tilegx_analyze_prologue): Likewise. (tilegx_stack_frame_destroyed_p): Likewise. (tilegx_frame_cache): Likewise. * tracefile.c (trace_save): Likewise. * tracepoint.c (encode_actions_and_make_cleanup): Likewise. (start_tracing): Likewise. (print_one_static_tracepoint_marker): Likewise. * tui/tui.c (tui_enable): Likewise. * valops.c (value_struct_elt_bitpos): Likewise. (find_overload_match): Likewise. (find_oload_champ): Likewise. * value.c (value_contents_copy_raw): Likewise. * windows-tdep.c (windows_get_tlb_type): Likewise. * x86-linux-nat.c (x86_linux_enable_btrace): Likewise. * xcoffread.c (record_minimal_symbol): Likewise. (scan_xcoff_symtab): Likewise. * xtensa-tdep.c (execute_code): Likewise. (xtensa_gdbarch_init): Likewise. (_initialize_xtensa_tdep): Likewise.
673 lines
19 KiB
C
673 lines
19 KiB
C
/* Target-dependent code for FT32.
|
|
|
|
Copyright (C) 2009-2016 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "frame.h"
|
|
#include "frame-unwind.h"
|
|
#include "frame-base.h"
|
|
#include "symtab.h"
|
|
#include "gdbtypes.h"
|
|
#include "gdbcmd.h"
|
|
#include "gdbcore.h"
|
|
#include "value.h"
|
|
#include "inferior.h"
|
|
#include "symfile.h"
|
|
#include "objfiles.h"
|
|
#include "osabi.h"
|
|
#include "language.h"
|
|
#include "arch-utils.h"
|
|
#include "regcache.h"
|
|
#include "trad-frame.h"
|
|
#include "dis-asm.h"
|
|
#include "record.h"
|
|
|
|
#include "opcode/ft32.h"
|
|
|
|
#include "ft32-tdep.h"
|
|
#include "gdb/sim-ft32.h"
|
|
|
|
#define RAM_BIAS 0x800000 /* Bias added to RAM addresses. */
|
|
|
|
/* Local functions. */
|
|
|
|
extern void _initialize_ft32_tdep (void);
|
|
|
|
/* Use an invalid address -1 as 'not available' marker. */
|
|
enum { REG_UNAVAIL = (CORE_ADDR) (-1) };
|
|
|
|
struct ft32_frame_cache
|
|
{
|
|
/* Base address of the frame */
|
|
CORE_ADDR base;
|
|
/* Function this frame belongs to */
|
|
CORE_ADDR pc;
|
|
/* Total size of this frame */
|
|
LONGEST framesize;
|
|
/* Saved registers in this frame */
|
|
CORE_ADDR saved_regs[FT32_NUM_REGS];
|
|
/* Saved SP in this frame */
|
|
CORE_ADDR saved_sp;
|
|
/* Has the new frame been LINKed. */
|
|
bfd_boolean established;
|
|
};
|
|
|
|
/* Implement the "frame_align" gdbarch method. */
|
|
|
|
static CORE_ADDR
|
|
ft32_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
|
|
{
|
|
/* Align to the size of an instruction (so that they can safely be
|
|
pushed onto the stack. */
|
|
return sp & ~1;
|
|
}
|
|
|
|
/* Implement the "breakpoint_from_pc" gdbarch method. */
|
|
|
|
static const unsigned char *
|
|
ft32_breakpoint_from_pc (struct gdbarch *gdbarch,
|
|
CORE_ADDR *pcptr, int *lenptr)
|
|
{
|
|
static const gdb_byte breakpoint[] = { 0x02, 0x00, 0x34, 0x00 };
|
|
|
|
*lenptr = sizeof (breakpoint);
|
|
return breakpoint;
|
|
}
|
|
|
|
/* FT32 register names. */
|
|
|
|
static const char *const ft32_register_names[] =
|
|
{
|
|
"fp", "sp",
|
|
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
|
|
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
|
|
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
|
|
"r24", "r25", "r26", "r27", "r28", "cc",
|
|
"pc"
|
|
};
|
|
|
|
/* Implement the "register_name" gdbarch method. */
|
|
|
|
static const char *
|
|
ft32_register_name (struct gdbarch *gdbarch, int reg_nr)
|
|
{
|
|
if (reg_nr < 0)
|
|
return NULL;
|
|
if (reg_nr >= FT32_NUM_REGS)
|
|
return NULL;
|
|
return ft32_register_names[reg_nr];
|
|
}
|
|
|
|
/* Implement the "register_type" gdbarch method. */
|
|
|
|
static struct type *
|
|
ft32_register_type (struct gdbarch *gdbarch, int reg_nr)
|
|
{
|
|
if (reg_nr == FT32_PC_REGNUM)
|
|
return gdbarch_tdep (gdbarch)->pc_type;
|
|
else if (reg_nr == FT32_SP_REGNUM || reg_nr == FT32_FP_REGNUM)
|
|
return builtin_type (gdbarch)->builtin_data_ptr;
|
|
else
|
|
return builtin_type (gdbarch)->builtin_int32;
|
|
}
|
|
|
|
/* Write into appropriate registers a function return value
|
|
of type TYPE, given in virtual format. */
|
|
|
|
static void
|
|
ft32_store_return_value (struct type *type, struct regcache *regcache,
|
|
const gdb_byte *valbuf)
|
|
{
|
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
CORE_ADDR regval;
|
|
int len = TYPE_LENGTH (type);
|
|
|
|
/* Things always get returned in RET1_REGNUM, RET2_REGNUM. */
|
|
regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len, byte_order);
|
|
regcache_cooked_write_unsigned (regcache, FT32_R0_REGNUM, regval);
|
|
if (len > 4)
|
|
{
|
|
regval = extract_unsigned_integer (valbuf + 4,
|
|
len - 4, byte_order);
|
|
regcache_cooked_write_unsigned (regcache, FT32_R1_REGNUM, regval);
|
|
}
|
|
}
|
|
|
|
/* Decode the instructions within the given address range. Decide
|
|
when we must have reached the end of the function prologue. If a
|
|
frame_info pointer is provided, fill in its saved_regs etc.
|
|
|
|
Returns the address of the first instruction after the prologue. */
|
|
|
|
static CORE_ADDR
|
|
ft32_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
|
|
struct ft32_frame_cache *cache,
|
|
struct gdbarch *gdbarch)
|
|
{
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
CORE_ADDR next_addr;
|
|
ULONGEST inst;
|
|
int regnum, pushreg;
|
|
struct bound_minimal_symbol msymbol;
|
|
const int first_saved_reg = 13; /* The first saved register. */
|
|
/* PROLOGS are addresses of the subroutine prologs, PROLOGS[n]
|
|
is the address of __prolog_$rN.
|
|
__prolog_$rN pushes registers from 13 through n inclusive.
|
|
So for example CALL __prolog_$r15 is equivalent to:
|
|
PUSH $r13
|
|
PUSH $r14
|
|
PUSH $r15
|
|
Note that PROLOGS[0] through PROLOGS[12] are unused. */
|
|
CORE_ADDR prologs[32];
|
|
|
|
cache->saved_regs[FT32_PC_REGNUM] = 0;
|
|
cache->framesize = 0;
|
|
|
|
for (regnum = first_saved_reg; regnum < 32; regnum++)
|
|
{
|
|
char prolog_symbol[32];
|
|
|
|
snprintf (prolog_symbol, sizeof (prolog_symbol), "__prolog_$r%02d",
|
|
regnum);
|
|
msymbol = lookup_minimal_symbol (prolog_symbol, NULL, NULL);
|
|
if (msymbol.minsym)
|
|
prologs[regnum] = BMSYMBOL_VALUE_ADDRESS (msymbol);
|
|
else
|
|
prologs[regnum] = 0;
|
|
}
|
|
|
|
if (start_addr >= end_addr)
|
|
return end_addr;
|
|
|
|
cache->established = 0;
|
|
for (next_addr = start_addr; next_addr < end_addr;)
|
|
{
|
|
inst = read_memory_unsigned_integer (next_addr, 4, byte_order);
|
|
|
|
if (FT32_IS_PUSH (inst))
|
|
{
|
|
pushreg = FT32_PUSH_REG (inst);
|
|
cache->framesize += 4;
|
|
cache->saved_regs[FT32_R0_REGNUM + pushreg] = cache->framesize;
|
|
next_addr += 4;
|
|
}
|
|
else if (FT32_IS_CALL (inst))
|
|
{
|
|
for (regnum = first_saved_reg; regnum < 32; regnum++)
|
|
{
|
|
if ((4 * (inst & 0x3ffff)) == prologs[regnum])
|
|
{
|
|
for (pushreg = first_saved_reg; pushreg <= regnum;
|
|
pushreg++)
|
|
{
|
|
cache->framesize += 4;
|
|
cache->saved_regs[FT32_R0_REGNUM + pushreg] =
|
|
cache->framesize;
|
|
}
|
|
next_addr += 4;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
for (regnum = FT32_R0_REGNUM; regnum < FT32_PC_REGNUM; regnum++)
|
|
{
|
|
if (cache->saved_regs[regnum] != REG_UNAVAIL)
|
|
cache->saved_regs[regnum] =
|
|
cache->framesize - cache->saved_regs[regnum];
|
|
}
|
|
cache->saved_regs[FT32_PC_REGNUM] = cache->framesize;
|
|
|
|
/* It is a LINK? */
|
|
if (next_addr < end_addr)
|
|
{
|
|
inst = read_memory_unsigned_integer (next_addr, 4, byte_order);
|
|
if (FT32_IS_LINK (inst))
|
|
{
|
|
cache->established = 1;
|
|
for (regnum = FT32_R0_REGNUM; regnum < FT32_PC_REGNUM; regnum++)
|
|
{
|
|
if (cache->saved_regs[regnum] != REG_UNAVAIL)
|
|
cache->saved_regs[regnum] += 4;
|
|
}
|
|
cache->saved_regs[FT32_PC_REGNUM] = cache->framesize + 4;
|
|
cache->saved_regs[FT32_FP_REGNUM] = 0;
|
|
cache->framesize += FT32_LINK_SIZE (inst);
|
|
next_addr += 4;
|
|
}
|
|
}
|
|
|
|
return next_addr;
|
|
}
|
|
|
|
/* Find the end of function prologue. */
|
|
|
|
static CORE_ADDR
|
|
ft32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
|
|
{
|
|
CORE_ADDR func_addr = 0, func_end = 0;
|
|
const char *func_name;
|
|
|
|
/* See if we can determine the end of the prologue via the symbol table.
|
|
If so, then return either PC, or the PC after the prologue, whichever
|
|
is greater. */
|
|
if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
|
|
{
|
|
CORE_ADDR post_prologue_pc
|
|
= skip_prologue_using_sal (gdbarch, func_addr);
|
|
if (post_prologue_pc != 0)
|
|
return max (pc, post_prologue_pc);
|
|
else
|
|
{
|
|
/* Can't determine prologue from the symbol table, need to examine
|
|
instructions. */
|
|
struct symtab_and_line sal;
|
|
struct symbol *sym;
|
|
struct ft32_frame_cache cache;
|
|
CORE_ADDR plg_end;
|
|
|
|
memset (&cache, 0, sizeof cache);
|
|
|
|
plg_end = ft32_analyze_prologue (func_addr,
|
|
func_end, &cache, gdbarch);
|
|
/* Found a function. */
|
|
sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
|
|
/* Don't use line number debug info for assembly source files. */
|
|
if ((sym != NULL) && SYMBOL_LANGUAGE (sym) != language_asm)
|
|
{
|
|
sal = find_pc_line (func_addr, 0);
|
|
if (sal.end && sal.end < func_end)
|
|
{
|
|
/* Found a line number, use it as end of prologue. */
|
|
return sal.end;
|
|
}
|
|
}
|
|
/* No useable line symbol. Use result of prologue parsing method. */
|
|
return plg_end;
|
|
}
|
|
}
|
|
|
|
/* No function symbol -- just return the PC. */
|
|
return pc;
|
|
}
|
|
|
|
/* Implementation of `pointer_to_address' gdbarch method.
|
|
|
|
On FT32 address space zero is RAM, address space 1 is flash.
|
|
RAM appears at address RAM_BIAS, flash at address 0. */
|
|
|
|
static CORE_ADDR
|
|
ft32_pointer_to_address (struct gdbarch *gdbarch,
|
|
struct type *type, const gdb_byte *buf)
|
|
{
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
CORE_ADDR addr
|
|
= extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
|
|
|
|
if (TYPE_ADDRESS_CLASS_1 (type))
|
|
return addr;
|
|
else
|
|
return addr | RAM_BIAS;
|
|
}
|
|
|
|
/* Implementation of `address_class_type_flags' gdbarch method.
|
|
|
|
This method maps DW_AT_address_class attributes to a
|
|
type_instance_flag_value. */
|
|
|
|
static int
|
|
ft32_address_class_type_flags (int byte_size, int dwarf2_addr_class)
|
|
{
|
|
/* The value 1 of the DW_AT_address_class attribute corresponds to the
|
|
__flash__ qualifier, meaning pointer to data in FT32 program memory.
|
|
*/
|
|
if (dwarf2_addr_class == 1)
|
|
return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
|
|
return 0;
|
|
}
|
|
|
|
/* Implementation of `address_class_type_flags_to_name' gdbarch method.
|
|
|
|
Convert a type_instance_flag_value to an address space qualifier. */
|
|
|
|
static const char*
|
|
ft32_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
|
|
{
|
|
if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
|
|
return "flash";
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
/* Implementation of `address_class_name_to_type_flags' gdbarch method.
|
|
|
|
Convert an address space qualifier to a type_instance_flag_value. */
|
|
|
|
static int
|
|
ft32_address_class_name_to_type_flags (struct gdbarch *gdbarch,
|
|
const char* name,
|
|
int *type_flags_ptr)
|
|
{
|
|
if (strcmp (name, "flash") == 0)
|
|
{
|
|
*type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
|
|
return 1;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Implement the "read_pc" gdbarch method. */
|
|
|
|
static CORE_ADDR
|
|
ft32_read_pc (struct regcache *regcache)
|
|
{
|
|
ULONGEST pc;
|
|
|
|
regcache_cooked_read_unsigned (regcache, FT32_PC_REGNUM, &pc);
|
|
return pc;
|
|
}
|
|
|
|
/* Implement the "write_pc" gdbarch method. */
|
|
|
|
static void
|
|
ft32_write_pc (struct regcache *regcache, CORE_ADDR val)
|
|
{
|
|
regcache_cooked_write_unsigned (regcache, FT32_PC_REGNUM, val);
|
|
}
|
|
|
|
/* Implement the "unwind_sp" gdbarch method. */
|
|
|
|
static CORE_ADDR
|
|
ft32_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
|
{
|
|
return frame_unwind_register_unsigned (next_frame, FT32_SP_REGNUM);
|
|
}
|
|
|
|
/* Given a return value in `regbuf' with a type `valtype',
|
|
extract and copy its value into `valbuf'. */
|
|
|
|
static void
|
|
ft32_extract_return_value (struct type *type, struct regcache *regcache,
|
|
gdb_byte *dst)
|
|
{
|
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
bfd_byte *valbuf = dst;
|
|
int len = TYPE_LENGTH (type);
|
|
ULONGEST tmp;
|
|
|
|
/* By using store_unsigned_integer we avoid having to do
|
|
anything special for small big-endian values. */
|
|
regcache_cooked_read_unsigned (regcache, FT32_R0_REGNUM, &tmp);
|
|
store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), byte_order, tmp);
|
|
|
|
/* Ignore return values more than 8 bytes in size because the ft32
|
|
returns anything more than 8 bytes in the stack. */
|
|
if (len > 4)
|
|
{
|
|
regcache_cooked_read_unsigned (regcache, FT32_R1_REGNUM, &tmp);
|
|
store_unsigned_integer (valbuf + len - 4, 4, byte_order, tmp);
|
|
}
|
|
}
|
|
|
|
/* Implement the "return_value" gdbarch method. */
|
|
|
|
static enum return_value_convention
|
|
ft32_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)
|
|
return RETURN_VALUE_STRUCT_CONVENTION;
|
|
else
|
|
{
|
|
if (readbuf != NULL)
|
|
ft32_extract_return_value (valtype, regcache, readbuf);
|
|
if (writebuf != NULL)
|
|
ft32_store_return_value (valtype, regcache, writebuf);
|
|
return RETURN_VALUE_REGISTER_CONVENTION;
|
|
}
|
|
}
|
|
|
|
/* Allocate and initialize a ft32_frame_cache object. */
|
|
|
|
static struct ft32_frame_cache *
|
|
ft32_alloc_frame_cache (void)
|
|
{
|
|
struct ft32_frame_cache *cache;
|
|
int i;
|
|
|
|
cache = FRAME_OBSTACK_ZALLOC (struct ft32_frame_cache);
|
|
|
|
for (i = 0; i < FT32_NUM_REGS; ++i)
|
|
cache->saved_regs[i] = REG_UNAVAIL;
|
|
|
|
return cache;
|
|
}
|
|
|
|
/* Populate a ft32_frame_cache object for this_frame. */
|
|
|
|
static struct ft32_frame_cache *
|
|
ft32_frame_cache (struct frame_info *this_frame, void **this_cache)
|
|
{
|
|
struct ft32_frame_cache *cache;
|
|
CORE_ADDR current_pc;
|
|
int i;
|
|
|
|
if (*this_cache)
|
|
return (struct ft32_frame_cache *) *this_cache;
|
|
|
|
cache = ft32_alloc_frame_cache ();
|
|
*this_cache = cache;
|
|
|
|
cache->base = get_frame_register_unsigned (this_frame, FT32_FP_REGNUM);
|
|
if (cache->base == 0)
|
|
return cache;
|
|
|
|
cache->pc = get_frame_func (this_frame);
|
|
current_pc = get_frame_pc (this_frame);
|
|
if (cache->pc)
|
|
{
|
|
struct gdbarch *gdbarch = get_frame_arch (this_frame);
|
|
|
|
ft32_analyze_prologue (cache->pc, current_pc, cache, gdbarch);
|
|
if (!cache->established)
|
|
cache->base = get_frame_register_unsigned (this_frame, FT32_SP_REGNUM);
|
|
}
|
|
|
|
cache->saved_sp = cache->base - 4;
|
|
|
|
for (i = 0; i < FT32_NUM_REGS; ++i)
|
|
if (cache->saved_regs[i] != REG_UNAVAIL)
|
|
cache->saved_regs[i] = cache->base + cache->saved_regs[i];
|
|
|
|
return cache;
|
|
}
|
|
|
|
/* Implement the "unwind_pc" gdbarch method. */
|
|
|
|
static CORE_ADDR
|
|
ft32_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
|
{
|
|
return frame_unwind_register_unsigned (next_frame, FT32_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
|
|
ft32_frame_this_id (struct frame_info *this_frame,
|
|
void **this_prologue_cache, struct frame_id *this_id)
|
|
{
|
|
struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
|
|
this_prologue_cache);
|
|
|
|
/* This marks the outermost frame. */
|
|
if (cache->base == 0)
|
|
return;
|
|
|
|
*this_id = frame_id_build (cache->saved_sp, cache->pc);
|
|
}
|
|
|
|
/* Get the value of register regnum in the previous stack frame. */
|
|
|
|
static struct value *
|
|
ft32_frame_prev_register (struct frame_info *this_frame,
|
|
void **this_prologue_cache, int regnum)
|
|
{
|
|
struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
|
|
this_prologue_cache);
|
|
|
|
gdb_assert (regnum >= 0);
|
|
|
|
if (regnum == FT32_SP_REGNUM && cache->saved_sp)
|
|
return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
|
|
|
|
if (regnum < FT32_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
|
|
return frame_unwind_got_memory (this_frame, regnum,
|
|
RAM_BIAS | cache->saved_regs[regnum]);
|
|
|
|
return frame_unwind_got_register (this_frame, regnum, regnum);
|
|
}
|
|
|
|
static const struct frame_unwind ft32_frame_unwind =
|
|
{
|
|
NORMAL_FRAME,
|
|
default_frame_unwind_stop_reason,
|
|
ft32_frame_this_id,
|
|
ft32_frame_prev_register,
|
|
NULL,
|
|
default_frame_sniffer
|
|
};
|
|
|
|
/* Return the base address of this_frame. */
|
|
|
|
static CORE_ADDR
|
|
ft32_frame_base_address (struct frame_info *this_frame, void **this_cache)
|
|
{
|
|
struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
|
|
this_cache);
|
|
|
|
return cache->base;
|
|
}
|
|
|
|
static const struct frame_base ft32_frame_base =
|
|
{
|
|
&ft32_frame_unwind,
|
|
ft32_frame_base_address,
|
|
ft32_frame_base_address,
|
|
ft32_frame_base_address
|
|
};
|
|
|
|
static struct frame_id
|
|
ft32_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
|
|
{
|
|
CORE_ADDR sp = get_frame_register_unsigned (this_frame, FT32_SP_REGNUM);
|
|
|
|
return frame_id_build (sp, get_frame_pc (this_frame));
|
|
}
|
|
|
|
/* Allocate and initialize the ft32 gdbarch object. */
|
|
|
|
static struct gdbarch *
|
|
ft32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
|
{
|
|
struct gdbarch *gdbarch;
|
|
struct gdbarch_tdep *tdep;
|
|
struct type *void_type;
|
|
struct type *func_void_type;
|
|
|
|
/* 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);
|
|
|
|
/* Create a type for PC. We can't use builtin types here, as they may not
|
|
be defined. */
|
|
void_type = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
|
|
func_void_type = make_function_type (void_type, NULL);
|
|
tdep->pc_type = arch_type (gdbarch, TYPE_CODE_PTR, 4, NULL);
|
|
TYPE_TARGET_TYPE (tdep->pc_type) = func_void_type;
|
|
TYPE_UNSIGNED (tdep->pc_type) = 1;
|
|
TYPE_INSTANCE_FLAGS (tdep->pc_type) |= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
|
|
|
|
set_gdbarch_read_pc (gdbarch, ft32_read_pc);
|
|
set_gdbarch_write_pc (gdbarch, ft32_write_pc);
|
|
set_gdbarch_unwind_sp (gdbarch, ft32_unwind_sp);
|
|
|
|
set_gdbarch_num_regs (gdbarch, FT32_NUM_REGS);
|
|
set_gdbarch_sp_regnum (gdbarch, FT32_SP_REGNUM);
|
|
set_gdbarch_pc_regnum (gdbarch, FT32_PC_REGNUM);
|
|
set_gdbarch_register_name (gdbarch, ft32_register_name);
|
|
set_gdbarch_register_type (gdbarch, ft32_register_type);
|
|
|
|
set_gdbarch_return_value (gdbarch, ft32_return_value);
|
|
|
|
set_gdbarch_pointer_to_address (gdbarch, ft32_pointer_to_address);
|
|
|
|
set_gdbarch_skip_prologue (gdbarch, ft32_skip_prologue);
|
|
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
|
|
set_gdbarch_breakpoint_from_pc (gdbarch, ft32_breakpoint_from_pc);
|
|
set_gdbarch_frame_align (gdbarch, ft32_frame_align);
|
|
|
|
frame_base_set_default (gdbarch, &ft32_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, ft32_dummy_id);
|
|
|
|
set_gdbarch_unwind_pc (gdbarch, ft32_unwind_pc);
|
|
|
|
set_gdbarch_print_insn (gdbarch, print_insn_ft32);
|
|
|
|
/* Hook in ABI-specific overrides, if they have been registered. */
|
|
gdbarch_init_osabi (info, gdbarch);
|
|
|
|
/* Hook in the default unwinders. */
|
|
frame_unwind_append_unwinder (gdbarch, &ft32_frame_unwind);
|
|
|
|
/* Support simple overlay manager. */
|
|
set_gdbarch_overlay_update (gdbarch, simple_overlay_update);
|
|
|
|
set_gdbarch_address_class_type_flags (gdbarch, ft32_address_class_type_flags);
|
|
set_gdbarch_address_class_name_to_type_flags
|
|
(gdbarch, ft32_address_class_name_to_type_flags);
|
|
set_gdbarch_address_class_type_flags_to_name
|
|
(gdbarch, ft32_address_class_type_flags_to_name);
|
|
|
|
return gdbarch;
|
|
}
|
|
|
|
/* Register this machine's init routine. */
|
|
|
|
void
|
|
_initialize_ft32_tdep (void)
|
|
{
|
|
register_gdbarch_init (bfd_arch_ft32, ft32_gdbarch_init);
|
|
}
|