/* Target-dependent code for the Texas Instruments MSP430 for GDB, the
GNU debugger.
- Copyright (C) 2012-2018 Free Software Foundation, Inc.
+ Copyright (C) 2012-2022 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
#include "frame-base.h"
#include "value.h"
#include "gdbcore.h"
-#include "dwarf2-frame.h"
+#include "dwarf2/frame.h"
#include "reggroups.h"
+#include "gdbarch.h"
#include "elf/msp430.h"
#include "opcode/msp430-decode.h"
/* Architecture specific data. */
-struct gdbarch_tdep
+struct msp430_gdbarch_tdep : gdbarch_tdep
{
/* The ELF header flags specify the multilib used. */
- int elf_flags;
+ int elf_flags = 0;
/* One of MSP_ISA_MSP430 or MSP_ISA_MSP430X. */
- int isa;
+ int isa = 0;
/* One of MSP_SMALL_CODE_MODEL or MSP_LARGE_CODE_MODEL. If, at
some point, we support different data models too, we'll probably
structure things so that we can combine values using logical
"or". */
- int code_model;
+ int code_model = 0;
};
/* This structure holds the results of a prologue analysis. */
static int
msp430_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
- struct reggroup *group)
+ const struct reggroup *group)
{
if (group == all_reggroup)
return 1;
int rn;
pv_t reg[MSP430_NUM_TOTAL_REGS];
CORE_ADDR after_last_frame_setup_insn = start_pc;
- int code_model = gdbarch_tdep (gdbarch)->code_model;
+ msp430_gdbarch_tdep *tdep = (msp430_gdbarch_tdep *) gdbarch_tdep (gdbarch);
+ int code_model = tdep->code_model;
int sz;
memset (result, 0, sizeof (*result));
return p.prologue_end;
}
-/* Implement the "unwind_pc" gdbarch method. */
-
-static CORE_ADDR
-msp430_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
-{
- return frame_unwind_register_unsigned (next_frame, MSP430_PC_REGNUM);
-}
-
-/* Implement the "unwind_sp" gdbarch method. */
-
-static CORE_ADDR
-msp430_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
-{
- return frame_unwind_register_unsigned (next_frame, MSP430_SP_REGNUM);
-}
-
/* Given a frame described by THIS_FRAME, decode the prologue of its
associated function if there is not cache entry as specified by
THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and
stop_addr = get_frame_pc (this_frame);
/* If we couldn't find any function containing the PC, then
- just initialize the prologue cache, but don't do anything. */
+ just initialize the prologue cache, but don't do anything. */
if (!func_start)
stop_addr = func_start;
}
static const struct frame_unwind msp430_unwind = {
+ "msp430 prologue",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
msp430_this_id,
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
LONGEST valtype_len = TYPE_LENGTH (valtype);
- int code_model = gdbarch_tdep (gdbarch)->code_model;
+ msp430_gdbarch_tdep *tdep = (msp430_gdbarch_tdep *) gdbarch_tdep (gdbarch);
+ int code_model = tdep->code_model;
if (TYPE_LENGTH (valtype) > 8
- || TYPE_CODE (valtype) == TYPE_CODE_STRUCT
- || TYPE_CODE (valtype) == TYPE_CODE_UNION)
+ || valtype->code () == TYPE_CODE_STRUCT
+ || valtype->code () == TYPE_CODE_UNION)
return RETURN_VALUE_STRUCT_CONVENTION;
if (readbuf)
int size = 2;
if (code_model == MSP_LARGE_CODE_MODEL
- && TYPE_CODE (valtype) == TYPE_CODE_PTR)
+ && valtype->code () == TYPE_CODE_PTR)
{
size = 4;
}
int size = 2;
if (code_model == MSP_LARGE_CODE_MODEL
- && TYPE_CODE (valtype) == TYPE_CODE_PTR)
+ && valtype->code () == TYPE_CODE_PTR)
{
size = 4;
}
return align_down (sp, 2);
}
-
-/* Implement the "dummy_id" gdbarch method. */
-
-static struct frame_id
-msp430_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
-{
- return
- frame_id_build (get_frame_register_unsigned
- (this_frame, MSP430_SP_REGNUM),
- get_frame_pc (this_frame));
-}
-
-
/* Implement the "push_dummy_call" gdbarch method. */
static CORE_ADDR
msp430_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)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int write_pass;
int sp_off = 0;
CORE_ADDR cfa;
- int code_model = gdbarch_tdep (gdbarch)->code_model;
+ msp430_gdbarch_tdep *tdep = (msp430_gdbarch_tdep *) gdbarch_tdep (gdbarch);
+ int code_model = tdep->code_model;
struct type *func_type = value_type (function);
/* Dereference function pointer types. */
- while (TYPE_CODE (func_type) == TYPE_CODE_PTR)
+ while (func_type->code () == TYPE_CODE_PTR)
func_type = TYPE_TARGET_TYPE (func_type);
/* The end result had better be a function or a method. */
- 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);
/* We make two passes; the first does the stack allocation,
the second actually stores the arguments. */
sp = align_down (sp - sp_off, 4);
sp_off = 0;
- if (struct_return)
+ if (return_method == return_method_struct)
{
if (write_pass)
regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);
for (i = 0; i < nargs; i++)
{
struct value *arg = args[i];
- const gdb_byte *arg_bits = value_contents_all (arg);
+ const gdb_byte *arg_bits = value_contents_all (arg).data ();
struct type *arg_type = check_typedef (value_type (arg));
ULONGEST arg_size = TYPE_LENGTH (arg_type);
int offset;
int current_arg_on_stack;
+ gdb_byte struct_addr_buf[4];
current_arg_on_stack = 0;
- if (TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
- || TYPE_CODE (arg_type) == TYPE_CODE_UNION)
+ if (arg_type->code () == TYPE_CODE_STRUCT
+ || arg_type->code () == TYPE_CODE_UNION)
{
/* Aggregates of any size are passed by reference. */
- gdb_byte struct_addr[4];
-
- store_unsigned_integer (struct_addr, 4, byte_order,
+ store_unsigned_integer (struct_addr_buf, 4, byte_order,
value_address (arg));
- arg_bits = struct_addr;
+ arg_bits = struct_addr_buf;
arg_size = (code_model == MSP_LARGE_CODE_MODEL) ? 4 : 2;
}
else
{
/* Scalars bigger than 8 bytes such as complex doubles are passed
- on the stack. */
+ on the stack. */
if (arg_size > 8)
current_arg_on_stack = 1;
}
for (offset = 0; offset < arg_size; offset += 2)
{
/* The condition below prevents 8 byte scalars from being split
- between registers and memory (stack). It also prevents other
- splits once the stack has been written to. */
+ between registers and memory (stack). It also prevents other
+ splits once the stack has been written to. */
if (!current_arg_on_stack
&& (arg_reg
+ ((arg_size == 8 || args_on_stack)
int size = 2;
if (code_model == MSP_LARGE_CODE_MODEL
- && (TYPE_CODE (arg_type) == TYPE_CODE_PTR
- || TYPE_IS_REFERENCE (arg_type)
- || TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
- || TYPE_CODE (arg_type) == TYPE_CODE_UNION))
+ && (arg_type->code () == TYPE_CODE_PTR
+ || TYPE_IS_REFERENCE (arg_type)
+ || arg_type->code () == TYPE_CODE_STRUCT
+ || arg_type->code () == TYPE_CODE_UNION))
{
/* When using the large memory model, pointer,
reference, struct, and union arguments are
/* Push the return address. */
{
- int sz = (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL)
- ? 2 : 4;
+ int sz = tdep->code_model == MSP_SMALL_CODE_MODEL ? 2 : 4;
sp = sp - sz;
write_memory_unsigned_integer (sp, sz, byte_order, bp_addr);
}
if (!bms.minsym)
return pc;
- stub_name = MSYMBOL_LINKAGE_NAME (bms.minsym);
+ stub_name = bms.minsym->linkage_name ();
- if (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL
+ msp430_gdbarch_tdep *tdep = (msp430_gdbarch_tdep *) gdbarch_tdep (gdbarch);
+ if (tdep->code_model == MSP_SMALL_CODE_MODEL
&& msp430_in_return_stub (gdbarch, pc, stub_name))
{
CORE_ADDR sp = get_frame_register_unsigned (frame, MSP430_SP_REGNUM);
msp430_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
struct gdbarch *gdbarch;
- struct gdbarch_tdep *tdep;
int elf_flags, isa, code_model;
/* Extract the elf_flags if available. */
struct gdbarch *ca = get_current_arch ();
if (ca && gdbarch_bfd_arch_info (ca)->arch == bfd_arch_msp430)
{
- struct gdbarch_tdep *ca_tdep = gdbarch_tdep (ca);
+ msp430_gdbarch_tdep *ca_tdep
+ = (msp430_gdbarch_tdep *) gdbarch_tdep (ca);
elf_flags = ca_tdep->elf_flags;
isa = ca_tdep->isa;
code_model = ca_tdep->code_model;
break;
}
- /* Otherwise, fall through... */
}
+ /* Fall through. */
default:
error (_("Unknown msp430 isa"));
break;
arches != NULL;
arches = gdbarch_list_lookup_by_info (arches->next, &info))
{
- struct gdbarch_tdep *candidate_tdep = gdbarch_tdep (arches->gdbarch);
+ msp430_gdbarch_tdep *candidate_tdep
+ = (msp430_gdbarch_tdep *) gdbarch_tdep (arches->gdbarch);
if (candidate_tdep->elf_flags != elf_flags
|| candidate_tdep->isa != isa
/* None found, create a new architecture from the information
provided. */
- tdep = XCNEW (struct gdbarch_tdep);
+ msp430_gdbarch_tdep *tdep = new msp430_gdbarch_tdep;
gdbarch = gdbarch_alloc (&info, tdep);
tdep->elf_flags = elf_flags;
tdep->isa = isa;
/* Frames, prologues, etc. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_skip_prologue (gdbarch, msp430_skip_prologue);
- set_gdbarch_unwind_pc (gdbarch, msp430_unwind_pc);
- set_gdbarch_unwind_sp (gdbarch, msp430_unwind_sp);
set_gdbarch_frame_align (gdbarch, msp430_frame_align);
dwarf2_append_unwinders (gdbarch);
frame_unwind_append_unwinder (gdbarch, &msp430_unwind);
/* Dummy frames, return values. */
- set_gdbarch_dummy_id (gdbarch, msp430_dummy_id);
set_gdbarch_push_dummy_call (gdbarch, msp430_push_dummy_call);
set_gdbarch_return_value (gdbarch, msp430_return_value);
/* Register the initialization routine. */
+void _initialize_msp430_tdep ();
void
-_initialize_msp430_tdep (void)
+_initialize_msp430_tdep ()
{
register_gdbarch_init (bfd_arch_msp430, msp430_gdbarch_init);
}