X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftic6x-tdep.c;h=57945d21db711f17fad49b0e4c35c44247f9bce9;hb=a350efd4fb368a35ada608f6bc26ccd3bed0ae6b;hp=145534a2671796e28bc0cd92ce912068aab738b5;hpb=fb090cfa157e35fac1c10c062fd005e38b894ea4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c index 145534a267..57945d21db 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-2016 Free Software Foundation, Inc. + Copyright (C) 2010-2020 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); @@ -346,14 +340,6 @@ tic6x_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size) return tdep->breakpoint; } -/* This is the implementation of gdbarch method print_insn. */ - -static int -tic6x_print_insn (bfd_vma memaddr, disassemble_info *info) -{ - return print_insn_tic6x (memaddr, info); -} - static void tic6x_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, @@ -390,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* @@ -606,7 +583,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; @@ -699,16 +676,12 @@ tic6x_get_next_pc (struct regcache *regcache, CORE_ADDR pc) /* This is the implementation of gdbarch method software_single_step. */ -static VEC (CORE_ADDR) * -tic6x_software_single_step (struct frame_info *frame) +static std::vector +tic6x_software_single_step (struct regcache *regcache) { - struct regcache *regcache = get_current_regcache (); CORE_ADDR next_pc = tic6x_get_next_pc (regcache, regcache_read_pc (regcache)); - VEC (CORE_ADDR) *next_pcs = NULL; - - VEC_safe_push (CORE_ADDR, next_pcs, next_pc); - return next_pcs; + return {next_pc}; } /* This is the implementation of gdbarch method frame_align. */ @@ -739,10 +712,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) { @@ -753,13 +725,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); } } } @@ -778,22 +750,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); } } } @@ -813,7 +784,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; } } @@ -831,23 +802,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) { @@ -895,13 +856,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 @@ -915,21 +876,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; + first_arg_on_stack = func_type->num_fields () - 1; /* Now make space on the stack for the args. */ for (argnum = 0; argnum < nargs; argnum++) @@ -954,7 +915,7 @@ 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); @@ -975,10 +936,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 { @@ -1005,19 +966,15 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function, 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 @@ -1091,7 +1048,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; @@ -1308,7 +1264,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); @@ -1322,15 +1277,11 @@ tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Single stepping. */ set_gdbarch_software_single_step (gdbarch, tic6x_software_single_step); - set_gdbarch_print_insn (gdbarch, tic6x_print_insn); - /* Call dummy code. */ set_gdbarch_frame_align (gdbarch, tic6x_frame_align); 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); @@ -1350,15 +1301,9 @@ tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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 (); }