X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=gdb%2Ftic6x-tdep.c;h=fb18b798db2f508295a3acfd9ea6aaceb325bc13;hb=a154d838a70e96d888620c072e2d6ea8bdf044ca;hp=156a54f3afc30ebbcd64381c476f283b5bcee3b8;hpb=39503f82427e22ed8e04d986ccdc8562091ec62e;p=thirdparty%2Fbinutils-gdb.git diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c index 156a54f3afc..fb18b798db2 100644 --- a/gdb/tic6x-tdep.c +++ b/gdb/tic6x-tdep.c @@ -1,6 +1,6 @@ /* Target dependent code for GDB on TI C6x systems. - Copyright (C) 2010-2017 Free Software Foundation, Inc. + Copyright (C) 2010-2021 Free Software Foundation, Inc. Contributed by Andrew Jenner Contributed by Yao Qi @@ -24,7 +24,7 @@ #include "frame-unwind.h" #include "frame-base.h" #include "trad-frame.h" -#include "dwarf2-frame.h" +#include "dwarf2/frame.h" #include "symtab.h" #include "inferior.h" #include "gdbtypes.h" @@ -36,7 +36,6 @@ #include "value.h" #include "symfile.h" #include "arch-utils.h" -#include "floatformat.h" #include "glibc-tdep.h" #include "infcall.h" #include "regset.h" @@ -50,10 +49,6 @@ #include "target-descriptions.h" #include -#include "features/tic6x-c64xp.c" -#include "features/tic6x-c64x.c" -#include "features/tic6x-c62x.c" - #define TIC6X_OPCODE_SIZE 4 #define TIC6X_FETCH_PACKET_SIZE 32 @@ -152,7 +147,6 @@ tic6x_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR start_pc, struct tic6x_unwind_cache *cache, struct frame_info *this_frame) { - unsigned long inst; unsigned int src_reg, base_reg, dst_reg; int i; CORE_ADDR pc = start_pc; @@ -247,7 +241,7 @@ tic6x_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR start_pc, } /* Step 2: Skip insn on setting up dsbt if it is. Usually, it looks like, ldw .D2T2 *+b14(0),b14 */ - inst = tic6x_fetch_instruction (gdbarch, pc); + unsigned long inst = tic6x_fetch_instruction (gdbarch, pc); /* The s bit determines which file dst will be loaded into, same effect as other places. */ dst_reg = tic6x_register_number ((inst >> 23) & 0x1f, (inst >> 1) & 1, 0); @@ -382,15 +376,6 @@ tic6x_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr); } -/* This is the implementation of gdbarch method unwind_sp. */ - -static CORE_ADDR -tic6x_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame) -{ - return frame_unwind_register_unsigned (this_frame, TIC6X_SP_REGNUM); -} - - /* Frame base handling. */ static struct tic6x_unwind_cache* @@ -472,6 +457,7 @@ tic6x_frame_base_address (struct frame_info *this_frame, void **this_cache) static const struct frame_unwind tic6x_frame_unwind = { + "tic6x prologue", NORMAL_FRAME, default_frame_unwind_stop_reason, tic6x_frame_this_id, @@ -534,6 +520,7 @@ tic6x_stub_unwind_sniffer (const struct frame_unwind *self, static const struct frame_unwind tic6x_stub_unwind = { + "tic6x stub", NORMAL_FRAME, default_frame_unwind_stop_reason, tic6x_stub_this_id, @@ -598,7 +585,7 @@ tic6x_extract_signed_field (int value, int low_bit, int bits) static CORE_ADDR tic6x_get_next_pc (struct regcache *regcache, CORE_ADDR pc) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); unsigned long inst; int register_number; int last = 0; @@ -727,10 +714,9 @@ tic6x_extract_return_value (struct type *valtype, struct regcache *regcache, register and the second byte occupies byte 0. so, we read the contents in VAL from the LSBs of register. */ if (len < 3 && byte_order == BFD_ENDIAN_BIG) - regcache_cooked_read_part (regcache, TIC6X_A4_REGNUM, 4 - len, len, - valbuf); + regcache->cooked_read_part (TIC6X_A4_REGNUM, 4 - len, len, valbuf); else - regcache_cooked_read (regcache, TIC6X_A4_REGNUM, valbuf); + regcache->cooked_read (TIC6X_A4_REGNUM, valbuf); } else if (len <= 8) { @@ -741,13 +727,13 @@ tic6x_extract_return_value (struct type *valtype, struct regcache *regcache, lower (even) register. */ if (byte_order == BFD_ENDIAN_BIG) { - regcache_cooked_read (regcache, TIC6X_A4_REGNUM, valbuf + 4); - regcache_cooked_read (regcache, TIC6X_A5_REGNUM, valbuf); + regcache->cooked_read (TIC6X_A4_REGNUM, valbuf + 4); + regcache->cooked_read (TIC6X_A5_REGNUM, valbuf); } else { - regcache_cooked_read (regcache, TIC6X_A4_REGNUM, valbuf); - regcache_cooked_read (regcache, TIC6X_A5_REGNUM, valbuf + 4); + regcache->cooked_read (TIC6X_A4_REGNUM, valbuf); + regcache->cooked_read (TIC6X_A5_REGNUM, valbuf + 4); } } } @@ -766,22 +752,21 @@ tic6x_store_return_value (struct type *valtype, struct regcache *regcache, if (len <= 4) { if (len < 3 && byte_order == BFD_ENDIAN_BIG) - regcache_cooked_write_part (regcache, TIC6X_A4_REGNUM, 4 - len, len, - valbuf); + regcache->cooked_write_part (TIC6X_A4_REGNUM, 4 - len, len, valbuf); else - regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf); + regcache->cooked_write (TIC6X_A4_REGNUM, valbuf); } else if (len <= 8) { if (byte_order == BFD_ENDIAN_BIG) { - regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf + 4); - regcache_cooked_write (regcache, TIC6X_A5_REGNUM, valbuf); + regcache->cooked_write (TIC6X_A4_REGNUM, valbuf + 4); + regcache->cooked_write (TIC6X_A5_REGNUM, valbuf); } else { - regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf); - regcache_cooked_write (regcache, TIC6X_A5_REGNUM, valbuf + 4); + regcache->cooked_write (TIC6X_A4_REGNUM, valbuf); + regcache->cooked_write (TIC6X_A5_REGNUM, valbuf + 4); } } } @@ -801,7 +786,7 @@ tic6x_return_value (struct gdbarch *gdbarch, struct value *function, if (type != NULL) { type = check_typedef (type); - if (language_pass_by_reference (type)) + if (!(language_pass_by_reference (type).trivially_copyable)) return RETURN_VALUE_STRUCT_CONVENTION; } } @@ -819,23 +804,13 @@ tic6x_return_value (struct gdbarch *gdbarch, struct value *function, return RETURN_VALUE_REGISTER_CONVENTION; } -/* This is the implementation of gdbarch method dummy_id. */ - -static struct frame_id -tic6x_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) -{ - return frame_id_build - (get_frame_register_unsigned (this_frame, TIC6X_SP_REGNUM), - get_frame_pc (this_frame)); -} - /* Get the alignment requirement of TYPE. */ static int tic6x_arg_type_alignment (struct type *type) { int len = TYPE_LENGTH (check_typedef (type)); - enum type_code typecode = TYPE_CODE (check_typedef (type)); + enum type_code typecode = check_typedef (type)->code (); if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION) { @@ -883,13 +858,13 @@ static CORE_ADDR tic6x_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) + function_call_return_method return_method, + CORE_ADDR struct_addr) { int argreg = 0; int argnum; int stack_offset = 4; int references_offset = 4; - CORE_ADDR func_addr = find_function_addr (function, NULL); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct type *func_type = value_type (function); /* The first arg passed on stack. Mostly the first 10 args are passed by @@ -903,21 +878,21 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* The caller must pass an argument in A3 containing a destination address for the returned value. The callee returns the object by copying it to the address in A3. */ - if (struct_return) + if (return_method == return_method_struct) regcache_cooked_write_unsigned (regcache, 3, struct_addr); /* Determine the type of this function. */ func_type = check_typedef (func_type); - if (TYPE_CODE (func_type) == TYPE_CODE_PTR) + if (func_type->code () == TYPE_CODE_PTR) func_type = check_typedef (TYPE_TARGET_TYPE (func_type)); - gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC - || TYPE_CODE (func_type) == TYPE_CODE_METHOD); + gdb_assert (func_type->code () == TYPE_CODE_FUNC + || func_type->code () == TYPE_CODE_METHOD); /* For a variadic C function, the last explicitly declared argument and all remaining arguments are passed on the stack. */ - if (TYPE_VARARGS (func_type)) - first_arg_on_stack = TYPE_NFIELDS (func_type) - 1; + if (func_type->has_varargs ()) + first_arg_on_stack = func_type->num_fields () - 1; /* Now make space on the stack for the args. */ for (argnum = 0; argnum < nargs; argnum++) @@ -942,12 +917,12 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct value *arg = args[argnum]; struct type *arg_type = check_typedef (value_type (arg)); int len = TYPE_LENGTH (arg_type); - enum type_code typecode = TYPE_CODE (arg_type); + enum type_code typecode = arg_type->code (); val = value_contents (arg); /* Copy the argument to general registers or the stack in - register-sized pieces. */ + register-sized pieces. */ if (argreg < first_arg_on_stack) { if (len <= 4) @@ -963,10 +938,10 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function, so, we write the contents in VAL to the lsp of register. */ if (len < 3 && byte_order == BFD_ENDIAN_BIG) - regcache_cooked_write_part (regcache, arg_regs[argreg], - 4 - len, len, val); + regcache->cooked_write_part (arg_regs[argreg], 4 - len, len, + val); else - regcache_cooked_write (regcache, arg_regs[argreg], val); + regcache->cooked_write (arg_regs[argreg], val); } else { @@ -987,31 +962,27 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function, || typecode == TYPE_CODE_UNION) { /* For a 5-8 byte structure or union in big-endian, the - first byte occupies byte 3 (the MSB) of the upper (odd) - register and the remaining bytes fill the decreasingly - significant bytes. 5-7 byte structures or unions have - padding in the LSBs of the lower (even) register. */ + first byte occupies byte 3 (the MSB) of the upper (odd) + register and the remaining bytes fill the decreasingly + significant bytes. 5-7 byte structures or unions have + padding in the LSBs of the lower (even) register. */ if (byte_order == BFD_ENDIAN_BIG) { - regcache_cooked_write (regcache, - arg_regs[argreg] + 1, val); - regcache_cooked_write_part (regcache, - arg_regs[argreg], 0, - len - 4, val + 4); + regcache->cooked_write (arg_regs[argreg] + 1, val); + regcache->cooked_write_part (arg_regs[argreg], 0, + len - 4, val + 4); } else { - regcache_cooked_write (regcache, arg_regs[argreg], - val); - regcache_cooked_write_part (regcache, - arg_regs[argreg] + 1, 0, - len - 4, val + 4); + regcache->cooked_write (arg_regs[argreg], val); + regcache->cooked_write_part (arg_regs[argreg] + 1, 0, + len - 4, val + 4); } } else { /* The argument is being passed by value in a pair of - registers. */ + registers. */ ULONGEST regval = extract_unsigned_integer (val, len, byte_order); @@ -1079,7 +1050,6 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (typecode == TYPE_CODE_COMPLEX) { /* The argument is being passed by reference on stack. */ - CORE_ADDR addr; references_offset = align_up (references_offset, 8); addr = sp + references_offset; @@ -1172,7 +1142,7 @@ tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) { struct gdbarch *gdbarch; struct gdbarch_tdep *tdep; - struct tdesc_arch_data *tdesc_data = NULL; + tdesc_arch_data_up tdesc_data; const struct target_desc *tdesc = info.target_desc; int has_gp = 0; @@ -1191,20 +1161,17 @@ tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) valid_p = 1; for (i = 0; i < 32; i++) /* A0 - A15, B0 - B15 */ - valid_p &= tdesc_numbered_register (feature, tdesc_data, i, + valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), i, tic6x_register_names[i]); /* CSR */ - valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, + valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), i++, tic6x_register_names[TIC6X_CSR_REGNUM]); - valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, + valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), i++, tic6x_register_names[TIC6X_PC_REGNUM]); if (!valid_p) - { - tdesc_data_cleanup (tdesc_data); - return NULL; - } + return NULL; feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.gp"); if (feature) @@ -1221,28 +1188,25 @@ tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) has_gp = 1; valid_p = 1; for (j = 0; j < 32; j++) /* A16 - A31, B16 - B31 */ - valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, - gp[j]); + valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), + i++, gp[j]); if (!valid_p) - { - tdesc_data_cleanup (tdesc_data); - return NULL; - } + return NULL; } feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.c6xp"); if (feature) { - valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "TSR"); - valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "ILC"); - valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "RILC"); + valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), + i++, "TSR"); + valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), + i++, "ILC"); + valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), + i++, "RILC"); if (!valid_p) - { - tdesc_data_cleanup (tdesc_data); - return NULL; - } + return NULL; } } @@ -1296,7 +1260,6 @@ tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tic6x_sw_breakpoint_from_kind); set_gdbarch_unwind_pc (gdbarch, tic6x_unwind_pc); - set_gdbarch_unwind_sp (gdbarch, tic6x_unwind_sp); /* Unwinding. */ dwarf2_append_unwinders (gdbarch); @@ -1315,8 +1278,6 @@ tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_return_value (gdbarch, tic6x_return_value); - set_gdbarch_dummy_id (gdbarch, tic6x_dummy_id); - /* Enable inferior call support. */ set_gdbarch_push_dummy_call (gdbarch, tic6x_push_dummy_call); @@ -1330,21 +1291,15 @@ tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Hook in ABI-specific overrides, if they have been registered. */ gdbarch_init_osabi (info, gdbarch); - if (tdesc_data) - tdesc_use_registers (gdbarch, tdesc, tdesc_data); + if (tdesc_data != nullptr) + tdesc_use_registers (gdbarch, tdesc, std::move (tdesc_data)); return gdbarch; } -/* -Wmissing-prototypes */ -extern initialize_file_ftype _initialize_tic6x_tdep; - +void _initialize_tic6x_tdep (); void -_initialize_tic6x_tdep (void) +_initialize_tic6x_tdep () { register_gdbarch_init (bfd_arch_tic6x, tic6x_gdbarch_init); - - initialize_tdesc_tic6x_c64xp (); - initialize_tdesc_tic6x_c64x (); - initialize_tdesc_tic6x_c62x (); }