2013-06-25 03:16:31 +02:00
|
|
|
/* Target-dependent code for the Texas Instruments MSP430 for GDB, the
|
|
|
|
GNU debugger.
|
|
|
|
|
2019-01-01 07:01:51 +01:00
|
|
|
Copyright (C) 2012-2019 Free Software Foundation, Inc.
|
2013-06-25 03:16:31 +02:00
|
|
|
|
|
|
|
Contributed by Red Hat, 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 "arch-utils.h"
|
|
|
|
#include "prologue-value.h"
|
|
|
|
#include "target.h"
|
|
|
|
#include "regcache.h"
|
|
|
|
#include "dis-asm.h"
|
|
|
|
#include "gdbtypes.h"
|
|
|
|
#include "frame.h"
|
|
|
|
#include "frame-unwind.h"
|
|
|
|
#include "frame-base.h"
|
|
|
|
#include "value.h"
|
|
|
|
#include "gdbcore.h"
|
|
|
|
#include "dwarf2-frame.h"
|
|
|
|
#include "reggroups.h"
|
|
|
|
|
|
|
|
#include "elf/msp430.h"
|
|
|
|
#include "opcode/msp430-decode.h"
|
|
|
|
#include "elf-bfd.h"
|
|
|
|
|
|
|
|
/* Register Numbers. */
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
MSP430_PC_RAW_REGNUM,
|
|
|
|
MSP430_SP_RAW_REGNUM,
|
|
|
|
MSP430_SR_RAW_REGNUM,
|
|
|
|
MSP430_CG_RAW_REGNUM,
|
|
|
|
MSP430_R4_RAW_REGNUM,
|
|
|
|
MSP430_R5_RAW_REGNUM,
|
|
|
|
MSP430_R6_RAW_REGNUM,
|
|
|
|
MSP430_R7_RAW_REGNUM,
|
|
|
|
MSP430_R8_RAW_REGNUM,
|
|
|
|
MSP430_R9_RAW_REGNUM,
|
|
|
|
MSP430_R10_RAW_REGNUM,
|
|
|
|
MSP430_R11_RAW_REGNUM,
|
|
|
|
MSP430_R12_RAW_REGNUM,
|
|
|
|
MSP430_R13_RAW_REGNUM,
|
|
|
|
MSP430_R14_RAW_REGNUM,
|
|
|
|
MSP430_R15_RAW_REGNUM,
|
|
|
|
|
|
|
|
MSP430_NUM_REGS,
|
|
|
|
|
|
|
|
MSP430_PC_REGNUM = MSP430_NUM_REGS,
|
|
|
|
MSP430_SP_REGNUM,
|
|
|
|
MSP430_SR_REGNUM,
|
|
|
|
MSP430_CG_REGNUM,
|
|
|
|
MSP430_R4_REGNUM,
|
|
|
|
MSP430_R5_REGNUM,
|
|
|
|
MSP430_R6_REGNUM,
|
|
|
|
MSP430_R7_REGNUM,
|
|
|
|
MSP430_R8_REGNUM,
|
|
|
|
MSP430_R9_REGNUM,
|
|
|
|
MSP430_R10_REGNUM,
|
|
|
|
MSP430_R11_REGNUM,
|
|
|
|
MSP430_R12_REGNUM,
|
|
|
|
MSP430_R13_REGNUM,
|
|
|
|
MSP430_R14_REGNUM,
|
|
|
|
MSP430_R15_REGNUM,
|
|
|
|
|
|
|
|
MSP430_NUM_TOTAL_REGS,
|
|
|
|
MSP430_NUM_PSEUDO_REGS = MSP430_NUM_TOTAL_REGS - MSP430_NUM_REGS
|
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
/* TI MSP430 Architecture. */
|
|
|
|
MSP_ISA_MSP430,
|
|
|
|
|
|
|
|
/* TI MSP430X Architecture. */
|
|
|
|
MSP_ISA_MSP430X
|
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
/* The small code model limits code addresses to 16 bits. */
|
|
|
|
MSP_SMALL_CODE_MODEL,
|
|
|
|
|
|
|
|
/* The large code model uses 20 bit addresses for function
|
|
|
|
pointers. These are stored in memory using four bytes (32 bits). */
|
|
|
|
MSP_LARGE_CODE_MODEL
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Architecture specific data. */
|
|
|
|
|
|
|
|
struct gdbarch_tdep
|
|
|
|
{
|
|
|
|
/* The ELF header flags specify the multilib used. */
|
|
|
|
int elf_flags;
|
|
|
|
|
|
|
|
/* One of MSP_ISA_MSP430 or MSP_ISA_MSP430X. */
|
|
|
|
int isa;
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* This structure holds the results of a prologue analysis. */
|
|
|
|
|
|
|
|
struct msp430_prologue
|
|
|
|
{
|
|
|
|
/* The offset from the frame base to the stack pointer --- always
|
|
|
|
zero or negative.
|
|
|
|
|
|
|
|
Calling this a "size" is a bit misleading, but given that the
|
|
|
|
stack grows downwards, using offsets for everything keeps one
|
|
|
|
from going completely sign-crazy: you never change anything's
|
|
|
|
sign for an ADD instruction; always change the second operand's
|
|
|
|
sign for a SUB instruction; and everything takes care of
|
|
|
|
itself. */
|
|
|
|
int frame_size;
|
|
|
|
|
|
|
|
/* Non-zero if this function has initialized the frame pointer from
|
|
|
|
the stack pointer, zero otherwise. */
|
|
|
|
int has_frame_ptr;
|
|
|
|
|
|
|
|
/* If has_frame_ptr is non-zero, this is the offset from the frame
|
|
|
|
base to where the frame pointer points. This is always zero or
|
|
|
|
negative. */
|
|
|
|
int frame_ptr_offset;
|
|
|
|
|
|
|
|
/* The address of the first instruction at which the frame has been
|
|
|
|
set up and the arguments are where the debug info says they are
|
|
|
|
--- as best as we can tell. */
|
|
|
|
CORE_ADDR prologue_end;
|
|
|
|
|
|
|
|
/* reg_offset[R] is the offset from the CFA at which register R is
|
|
|
|
saved, or 1 if register R has not been saved. (Real values are
|
|
|
|
always zero or negative.) */
|
|
|
|
int reg_offset[MSP430_NUM_TOTAL_REGS];
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Implement the "register_type" gdbarch method. */
|
|
|
|
|
|
|
|
static struct type *
|
|
|
|
msp430_register_type (struct gdbarch *gdbarch, int reg_nr)
|
|
|
|
{
|
|
|
|
if (reg_nr < MSP430_NUM_REGS)
|
|
|
|
return builtin_type (gdbarch)->builtin_uint32;
|
|
|
|
else if (reg_nr == MSP430_PC_REGNUM)
|
|
|
|
return builtin_type (gdbarch)->builtin_func_ptr;
|
|
|
|
else
|
|
|
|
return builtin_type (gdbarch)->builtin_uint16;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement another version of the "register_type" gdbarch method
|
|
|
|
for msp430x. */
|
|
|
|
|
|
|
|
static struct type *
|
|
|
|
msp430x_register_type (struct gdbarch *gdbarch, int reg_nr)
|
|
|
|
{
|
|
|
|
if (reg_nr < MSP430_NUM_REGS)
|
|
|
|
return builtin_type (gdbarch)->builtin_uint32;
|
|
|
|
else if (reg_nr == MSP430_PC_REGNUM)
|
|
|
|
return builtin_type (gdbarch)->builtin_func_ptr;
|
|
|
|
else
|
|
|
|
return builtin_type (gdbarch)->builtin_uint32;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "register_name" gdbarch method. */
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
msp430_register_name (struct gdbarch *gdbarch, int regnr)
|
|
|
|
{
|
|
|
|
static const char *const reg_names[] = {
|
|
|
|
/* Raw registers. */
|
|
|
|
"", "", "", "", "", "", "", "",
|
|
|
|
"", "", "", "", "", "", "", "",
|
|
|
|
/* Pseudo registers. */
|
|
|
|
"pc", "sp", "sr", "cg", "r4", "r5", "r6", "r7",
|
|
|
|
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
|
|
|
|
};
|
|
|
|
|
|
|
|
return reg_names[regnr];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "register_reggroup_p" gdbarch method. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
msp430_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
|
|
|
|
struct reggroup *group)
|
|
|
|
{
|
|
|
|
if (group == all_reggroup)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* All other registers are saved and restored. */
|
|
|
|
if (group == save_reggroup || group == restore_reggroup)
|
|
|
|
return (MSP430_NUM_REGS <= regnum && regnum < MSP430_NUM_TOTAL_REGS);
|
|
|
|
|
|
|
|
return group == general_reggroup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "pseudo_register_read" gdbarch method. */
|
|
|
|
|
|
|
|
static enum register_status
|
|
|
|
msp430_pseudo_register_read (struct gdbarch *gdbarch,
|
2018-02-21 12:20:03 +01:00
|
|
|
readable_regcache *regcache,
|
2013-06-25 03:16:31 +02:00
|
|
|
int regnum, gdb_byte *buffer)
|
|
|
|
{
|
|
|
|
if (MSP430_NUM_REGS <= regnum && regnum < MSP430_NUM_TOTAL_REGS)
|
|
|
|
{
|
2017-04-10 16:01:53 +02:00
|
|
|
enum register_status status;
|
2013-06-25 03:16:31 +02:00
|
|
|
ULONGEST val;
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
int regsize = register_size (gdbarch, regnum);
|
|
|
|
int raw_regnum = regnum - MSP430_NUM_REGS;
|
|
|
|
|
2018-01-22 12:02:49 +01:00
|
|
|
status = regcache->raw_read (raw_regnum, &val);
|
2013-06-25 03:16:31 +02:00
|
|
|
if (status == REG_VALID)
|
|
|
|
store_unsigned_integer (buffer, regsize, byte_order, val);
|
|
|
|
|
2017-04-10 16:01:53 +02:00
|
|
|
return status;
|
2013-06-25 03:16:31 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
gdb_assert_not_reached ("invalid pseudo register number");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "pseudo_register_write" gdbarch method. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
msp430_pseudo_register_write (struct gdbarch *gdbarch,
|
|
|
|
struct regcache *regcache,
|
|
|
|
int regnum, const gdb_byte *buffer)
|
|
|
|
{
|
|
|
|
if (MSP430_NUM_REGS <= regnum && regnum < MSP430_NUM_TOTAL_REGS)
|
|
|
|
|
|
|
|
{
|
|
|
|
ULONGEST val;
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
int regsize = register_size (gdbarch, regnum);
|
|
|
|
int raw_regnum = regnum - MSP430_NUM_REGS;
|
|
|
|
|
|
|
|
val = extract_unsigned_integer (buffer, regsize, byte_order);
|
|
|
|
regcache_raw_write_unsigned (regcache, raw_regnum, val);
|
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gdb_assert_not_reached ("invalid pseudo register number");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the `register_sim_regno' gdbarch method. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
msp430_register_sim_regno (struct gdbarch *gdbarch, int regnum)
|
|
|
|
{
|
|
|
|
gdb_assert (regnum < MSP430_NUM_REGS);
|
|
|
|
|
|
|
|
/* So long as regnum is in [0, RL78_NUM_REGS), it's valid. We
|
|
|
|
just want to override the default here which disallows register
|
|
|
|
numbers which have no names. */
|
|
|
|
return regnum;
|
|
|
|
}
|
|
|
|
|
2016-11-03 15:35:14 +01:00
|
|
|
constexpr gdb_byte msp430_break_insn[] = { 0x43, 0x43 };
|
2013-06-25 03:16:31 +02:00
|
|
|
|
2016-11-03 15:35:14 +01:00
|
|
|
typedef BP_MANIPULATION (msp430_break_insn) msp430_breakpoint;
|
2013-06-25 03:16:31 +02:00
|
|
|
|
|
|
|
/* Define a "handle" struct for fetching the next opcode. */
|
|
|
|
|
|
|
|
struct msp430_get_opcode_byte_handle
|
|
|
|
{
|
|
|
|
CORE_ADDR pc;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Fetch a byte on behalf of the opcode decoder. HANDLE contains
|
|
|
|
the memory address of the next byte to fetch. If successful,
|
|
|
|
the address in the handle is updated and the byte fetched is
|
|
|
|
returned as the value of the function. If not successful, -1
|
|
|
|
is returned. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
msp430_get_opcode_byte (void *handle)
|
|
|
|
{
|
2015-09-25 20:08:07 +02:00
|
|
|
struct msp430_get_opcode_byte_handle *opcdata
|
|
|
|
= (struct msp430_get_opcode_byte_handle *) handle;
|
2013-06-25 03:16:31 +02:00
|
|
|
int status;
|
|
|
|
gdb_byte byte;
|
|
|
|
|
|
|
|
status = target_read_memory (opcdata->pc, &byte, 1);
|
|
|
|
if (status == 0)
|
|
|
|
{
|
|
|
|
opcdata->pc += 1;
|
|
|
|
return byte;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function for finding saved registers in a 'struct pv_area'; this
|
C++-ify prologue-value's pv_area
This patch is an initial C++-ification of pv_area, from
prologue-value. It turns pv_area into a class with a constructor and
destructor; renames the data members; and changes various functions to
be member functions. This allows the removal of
make_cleanup_free_pv_area.
gdb/ChangeLog
2017-10-12 Tom Tromey <tom@tromey.com>
* s390-linux-tdep.c (s390_store, s390_load)
(s390_check_for_saved, s390_analyze_prologue): Update.
* rx-tdep.c (check_for_saved, rx_analyze_prologue): Update.
* rl78-tdep.c (rl78_analyze_prologue, check_for_saved): Update.
* prologue-value.h (class pv_area): Move from prologue-value.c.
Change names of members. Add constructor, destructor, member
functions.
(make_pv_area, free_pv_area, make_cleanup_free_pv_area)
(pv_area_store, pv_area_fetch, pv_area_store_would_trash)
(pv_area_fetch, pv_area_scan): Don't declare.
* prologue-value.c (struct pv_area::area_entry): Now member of
pv_area.
(struct pv_area): Move to prologue-value.h.
(pv_area::pv_area): Rename from make_pv_area.
(pv_area::~pv_area): Rename from free_pv_area.
(do_free_pv_area_cleanup, make_cleanup_free_pv_area): Remove.
(clear_entries, find_entry, overlaps, store_would_trash, store)
(fetch, find_reg, scan): Now member of pv_area.
Remove "area" argument. Update.
* msp430-tdep.c (check_for_saved, msp430_analyze_prologue):
Update.
* mn10300-tdep.c (push_reg, check_for_saved)
(mn10300_analyze_prologue): Update.
* mep-tdep.c (is_arg_spill, check_for_saved)
(mep_analyze_prologue): Update.
* m32c-tdep.c (m32c_pv_push, m32c_srcdest_fetch)
(m32c_srcdest_store, m32c_pv_enter, m32c_is_arg_spill)
(m32c_is_struct_return, m32c_analyze_prologue): Update.
* arm-tdep.c (thumb_analyze_prologue, arm_analyze_prologue):
Update.
* arc-tdep.c (arc_is_in_prologue, arc_analyze_prologue): Update.
* aarch64-tdep.c (aarch64_analyze_prologue): Update.
2017-10-08 02:23:36 +02:00
|
|
|
function is passed to pv_area::scan.
|
2013-06-25 03:16:31 +02:00
|
|
|
|
|
|
|
If VALUE is a saved register, ADDR says it was saved at a constant
|
|
|
|
offset from the frame base, and SIZE indicates that the whole
|
|
|
|
register was saved, record its offset. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
|
|
|
|
{
|
|
|
|
struct msp430_prologue *result = (struct msp430_prologue *) result_untyped;
|
|
|
|
|
|
|
|
if (value.kind == pvk_register
|
|
|
|
&& value.k == 0
|
|
|
|
&& pv_is_register (addr, MSP430_SP_REGNUM)
|
|
|
|
&& size == register_size (target_gdbarch (), value.reg))
|
|
|
|
result->reg_offset[value.reg] = addr.k;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Analyze a prologue starting at START_PC, going no further than
|
|
|
|
LIMIT_PC. Fill in RESULT as appropriate. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
msp430_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc,
|
|
|
|
CORE_ADDR limit_pc, struct msp430_prologue *result)
|
|
|
|
{
|
|
|
|
CORE_ADDR pc, next_pc;
|
|
|
|
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;
|
|
|
|
int sz;
|
|
|
|
|
|
|
|
memset (result, 0, sizeof (*result));
|
|
|
|
|
|
|
|
for (rn = 0; rn < MSP430_NUM_TOTAL_REGS; rn++)
|
|
|
|
{
|
|
|
|
reg[rn] = pv_register (rn, 0);
|
|
|
|
result->reg_offset[rn] = 1;
|
|
|
|
}
|
|
|
|
|
C++-ify prologue-value's pv_area
This patch is an initial C++-ification of pv_area, from
prologue-value. It turns pv_area into a class with a constructor and
destructor; renames the data members; and changes various functions to
be member functions. This allows the removal of
make_cleanup_free_pv_area.
gdb/ChangeLog
2017-10-12 Tom Tromey <tom@tromey.com>
* s390-linux-tdep.c (s390_store, s390_load)
(s390_check_for_saved, s390_analyze_prologue): Update.
* rx-tdep.c (check_for_saved, rx_analyze_prologue): Update.
* rl78-tdep.c (rl78_analyze_prologue, check_for_saved): Update.
* prologue-value.h (class pv_area): Move from prologue-value.c.
Change names of members. Add constructor, destructor, member
functions.
(make_pv_area, free_pv_area, make_cleanup_free_pv_area)
(pv_area_store, pv_area_fetch, pv_area_store_would_trash)
(pv_area_fetch, pv_area_scan): Don't declare.
* prologue-value.c (struct pv_area::area_entry): Now member of
pv_area.
(struct pv_area): Move to prologue-value.h.
(pv_area::pv_area): Rename from make_pv_area.
(pv_area::~pv_area): Rename from free_pv_area.
(do_free_pv_area_cleanup, make_cleanup_free_pv_area): Remove.
(clear_entries, find_entry, overlaps, store_would_trash, store)
(fetch, find_reg, scan): Now member of pv_area.
Remove "area" argument. Update.
* msp430-tdep.c (check_for_saved, msp430_analyze_prologue):
Update.
* mn10300-tdep.c (push_reg, check_for_saved)
(mn10300_analyze_prologue): Update.
* mep-tdep.c (is_arg_spill, check_for_saved)
(mep_analyze_prologue): Update.
* m32c-tdep.c (m32c_pv_push, m32c_srcdest_fetch)
(m32c_srcdest_store, m32c_pv_enter, m32c_is_arg_spill)
(m32c_is_struct_return, m32c_analyze_prologue): Update.
* arm-tdep.c (thumb_analyze_prologue, arm_analyze_prologue):
Update.
* arc-tdep.c (arc_is_in_prologue, arc_analyze_prologue): Update.
* aarch64-tdep.c (aarch64_analyze_prologue): Update.
2017-10-08 02:23:36 +02:00
|
|
|
pv_area stack (MSP430_SP_REGNUM, gdbarch_addr_bit (gdbarch));
|
2013-06-25 03:16:31 +02:00
|
|
|
|
|
|
|
/* The call instruction has saved the return address on the stack. */
|
|
|
|
sz = code_model == MSP_LARGE_CODE_MODEL ? 4 : 2;
|
|
|
|
reg[MSP430_SP_REGNUM] = pv_add_constant (reg[MSP430_SP_REGNUM], -sz);
|
C++-ify prologue-value's pv_area
This patch is an initial C++-ification of pv_area, from
prologue-value. It turns pv_area into a class with a constructor and
destructor; renames the data members; and changes various functions to
be member functions. This allows the removal of
make_cleanup_free_pv_area.
gdb/ChangeLog
2017-10-12 Tom Tromey <tom@tromey.com>
* s390-linux-tdep.c (s390_store, s390_load)
(s390_check_for_saved, s390_analyze_prologue): Update.
* rx-tdep.c (check_for_saved, rx_analyze_prologue): Update.
* rl78-tdep.c (rl78_analyze_prologue, check_for_saved): Update.
* prologue-value.h (class pv_area): Move from prologue-value.c.
Change names of members. Add constructor, destructor, member
functions.
(make_pv_area, free_pv_area, make_cleanup_free_pv_area)
(pv_area_store, pv_area_fetch, pv_area_store_would_trash)
(pv_area_fetch, pv_area_scan): Don't declare.
* prologue-value.c (struct pv_area::area_entry): Now member of
pv_area.
(struct pv_area): Move to prologue-value.h.
(pv_area::pv_area): Rename from make_pv_area.
(pv_area::~pv_area): Rename from free_pv_area.
(do_free_pv_area_cleanup, make_cleanup_free_pv_area): Remove.
(clear_entries, find_entry, overlaps, store_would_trash, store)
(fetch, find_reg, scan): Now member of pv_area.
Remove "area" argument. Update.
* msp430-tdep.c (check_for_saved, msp430_analyze_prologue):
Update.
* mn10300-tdep.c (push_reg, check_for_saved)
(mn10300_analyze_prologue): Update.
* mep-tdep.c (is_arg_spill, check_for_saved)
(mep_analyze_prologue): Update.
* m32c-tdep.c (m32c_pv_push, m32c_srcdest_fetch)
(m32c_srcdest_store, m32c_pv_enter, m32c_is_arg_spill)
(m32c_is_struct_return, m32c_analyze_prologue): Update.
* arm-tdep.c (thumb_analyze_prologue, arm_analyze_prologue):
Update.
* arc-tdep.c (arc_is_in_prologue, arc_analyze_prologue): Update.
* aarch64-tdep.c (aarch64_analyze_prologue): Update.
2017-10-08 02:23:36 +02:00
|
|
|
stack.store (reg[MSP430_SP_REGNUM], sz, reg[MSP430_PC_REGNUM]);
|
2013-06-25 03:16:31 +02:00
|
|
|
|
|
|
|
pc = start_pc;
|
|
|
|
while (pc < limit_pc)
|
|
|
|
{
|
|
|
|
int bytes_read;
|
|
|
|
struct msp430_get_opcode_byte_handle opcode_handle;
|
|
|
|
MSP430_Opcode_Decoded opc;
|
|
|
|
|
|
|
|
opcode_handle.pc = pc;
|
|
|
|
bytes_read = msp430_decode_opcode (pc, &opc, msp430_get_opcode_byte,
|
|
|
|
&opcode_handle);
|
|
|
|
next_pc = pc + bytes_read;
|
|
|
|
|
|
|
|
if (opc.id == MSO_push && opc.op[0].type == MSP430_Operand_Register)
|
|
|
|
{
|
|
|
|
int rsrc = opc.op[0].reg;
|
|
|
|
|
|
|
|
reg[MSP430_SP_REGNUM] = pv_add_constant (reg[MSP430_SP_REGNUM], -2);
|
C++-ify prologue-value's pv_area
This patch is an initial C++-ification of pv_area, from
prologue-value. It turns pv_area into a class with a constructor and
destructor; renames the data members; and changes various functions to
be member functions. This allows the removal of
make_cleanup_free_pv_area.
gdb/ChangeLog
2017-10-12 Tom Tromey <tom@tromey.com>
* s390-linux-tdep.c (s390_store, s390_load)
(s390_check_for_saved, s390_analyze_prologue): Update.
* rx-tdep.c (check_for_saved, rx_analyze_prologue): Update.
* rl78-tdep.c (rl78_analyze_prologue, check_for_saved): Update.
* prologue-value.h (class pv_area): Move from prologue-value.c.
Change names of members. Add constructor, destructor, member
functions.
(make_pv_area, free_pv_area, make_cleanup_free_pv_area)
(pv_area_store, pv_area_fetch, pv_area_store_would_trash)
(pv_area_fetch, pv_area_scan): Don't declare.
* prologue-value.c (struct pv_area::area_entry): Now member of
pv_area.
(struct pv_area): Move to prologue-value.h.
(pv_area::pv_area): Rename from make_pv_area.
(pv_area::~pv_area): Rename from free_pv_area.
(do_free_pv_area_cleanup, make_cleanup_free_pv_area): Remove.
(clear_entries, find_entry, overlaps, store_would_trash, store)
(fetch, find_reg, scan): Now member of pv_area.
Remove "area" argument. Update.
* msp430-tdep.c (check_for_saved, msp430_analyze_prologue):
Update.
* mn10300-tdep.c (push_reg, check_for_saved)
(mn10300_analyze_prologue): Update.
* mep-tdep.c (is_arg_spill, check_for_saved)
(mep_analyze_prologue): Update.
* m32c-tdep.c (m32c_pv_push, m32c_srcdest_fetch)
(m32c_srcdest_store, m32c_pv_enter, m32c_is_arg_spill)
(m32c_is_struct_return, m32c_analyze_prologue): Update.
* arm-tdep.c (thumb_analyze_prologue, arm_analyze_prologue):
Update.
* arc-tdep.c (arc_is_in_prologue, arc_analyze_prologue): Update.
* aarch64-tdep.c (aarch64_analyze_prologue): Update.
2017-10-08 02:23:36 +02:00
|
|
|
stack.store (reg[MSP430_SP_REGNUM], 2, reg[rsrc]);
|
2013-06-25 03:16:31 +02:00
|
|
|
after_last_frame_setup_insn = next_pc;
|
|
|
|
}
|
|
|
|
else if (opc.id == MSO_push /* PUSHM */
|
|
|
|
&& opc.op[0].type == MSP430_Operand_None
|
|
|
|
&& opc.op[1].type == MSP430_Operand_Register)
|
|
|
|
{
|
|
|
|
int rsrc = opc.op[1].reg;
|
|
|
|
int count = opc.repeats + 1;
|
|
|
|
int size = opc.size == 16 ? 2 : 4;
|
|
|
|
|
|
|
|
while (count > 0)
|
|
|
|
{
|
|
|
|
reg[MSP430_SP_REGNUM]
|
|
|
|
= pv_add_constant (reg[MSP430_SP_REGNUM], -size);
|
C++-ify prologue-value's pv_area
This patch is an initial C++-ification of pv_area, from
prologue-value. It turns pv_area into a class with a constructor and
destructor; renames the data members; and changes various functions to
be member functions. This allows the removal of
make_cleanup_free_pv_area.
gdb/ChangeLog
2017-10-12 Tom Tromey <tom@tromey.com>
* s390-linux-tdep.c (s390_store, s390_load)
(s390_check_for_saved, s390_analyze_prologue): Update.
* rx-tdep.c (check_for_saved, rx_analyze_prologue): Update.
* rl78-tdep.c (rl78_analyze_prologue, check_for_saved): Update.
* prologue-value.h (class pv_area): Move from prologue-value.c.
Change names of members. Add constructor, destructor, member
functions.
(make_pv_area, free_pv_area, make_cleanup_free_pv_area)
(pv_area_store, pv_area_fetch, pv_area_store_would_trash)
(pv_area_fetch, pv_area_scan): Don't declare.
* prologue-value.c (struct pv_area::area_entry): Now member of
pv_area.
(struct pv_area): Move to prologue-value.h.
(pv_area::pv_area): Rename from make_pv_area.
(pv_area::~pv_area): Rename from free_pv_area.
(do_free_pv_area_cleanup, make_cleanup_free_pv_area): Remove.
(clear_entries, find_entry, overlaps, store_would_trash, store)
(fetch, find_reg, scan): Now member of pv_area.
Remove "area" argument. Update.
* msp430-tdep.c (check_for_saved, msp430_analyze_prologue):
Update.
* mn10300-tdep.c (push_reg, check_for_saved)
(mn10300_analyze_prologue): Update.
* mep-tdep.c (is_arg_spill, check_for_saved)
(mep_analyze_prologue): Update.
* m32c-tdep.c (m32c_pv_push, m32c_srcdest_fetch)
(m32c_srcdest_store, m32c_pv_enter, m32c_is_arg_spill)
(m32c_is_struct_return, m32c_analyze_prologue): Update.
* arm-tdep.c (thumb_analyze_prologue, arm_analyze_prologue):
Update.
* arc-tdep.c (arc_is_in_prologue, arc_analyze_prologue): Update.
* aarch64-tdep.c (aarch64_analyze_prologue): Update.
2017-10-08 02:23:36 +02:00
|
|
|
stack.store (reg[MSP430_SP_REGNUM], size, reg[rsrc]);
|
2013-06-25 03:16:31 +02:00
|
|
|
rsrc--;
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
after_last_frame_setup_insn = next_pc;
|
|
|
|
}
|
|
|
|
else if (opc.id == MSO_sub
|
|
|
|
&& opc.op[0].type == MSP430_Operand_Register
|
|
|
|
&& opc.op[0].reg == MSR_SP
|
|
|
|
&& opc.op[1].type == MSP430_Operand_Immediate)
|
|
|
|
{
|
|
|
|
int addend = opc.op[1].addend;
|
|
|
|
|
|
|
|
reg[MSP430_SP_REGNUM] = pv_add_constant (reg[MSP430_SP_REGNUM],
|
|
|
|
-addend);
|
|
|
|
after_last_frame_setup_insn = next_pc;
|
|
|
|
}
|
|
|
|
else if (opc.id == MSO_mov
|
|
|
|
&& opc.op[0].type == MSP430_Operand_Immediate
|
|
|
|
&& 12 <= opc.op[0].reg && opc.op[0].reg <= 15)
|
|
|
|
after_last_frame_setup_insn = next_pc;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Terminate the prologue scan. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
pc = next_pc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is the frame size (offset, really) a known constant? */
|
|
|
|
if (pv_is_register (reg[MSP430_SP_REGNUM], MSP430_SP_REGNUM))
|
|
|
|
result->frame_size = reg[MSP430_SP_REGNUM].k;
|
|
|
|
|
|
|
|
/* Record where all the registers were saved. */
|
C++-ify prologue-value's pv_area
This patch is an initial C++-ification of pv_area, from
prologue-value. It turns pv_area into a class with a constructor and
destructor; renames the data members; and changes various functions to
be member functions. This allows the removal of
make_cleanup_free_pv_area.
gdb/ChangeLog
2017-10-12 Tom Tromey <tom@tromey.com>
* s390-linux-tdep.c (s390_store, s390_load)
(s390_check_for_saved, s390_analyze_prologue): Update.
* rx-tdep.c (check_for_saved, rx_analyze_prologue): Update.
* rl78-tdep.c (rl78_analyze_prologue, check_for_saved): Update.
* prologue-value.h (class pv_area): Move from prologue-value.c.
Change names of members. Add constructor, destructor, member
functions.
(make_pv_area, free_pv_area, make_cleanup_free_pv_area)
(pv_area_store, pv_area_fetch, pv_area_store_would_trash)
(pv_area_fetch, pv_area_scan): Don't declare.
* prologue-value.c (struct pv_area::area_entry): Now member of
pv_area.
(struct pv_area): Move to prologue-value.h.
(pv_area::pv_area): Rename from make_pv_area.
(pv_area::~pv_area): Rename from free_pv_area.
(do_free_pv_area_cleanup, make_cleanup_free_pv_area): Remove.
(clear_entries, find_entry, overlaps, store_would_trash, store)
(fetch, find_reg, scan): Now member of pv_area.
Remove "area" argument. Update.
* msp430-tdep.c (check_for_saved, msp430_analyze_prologue):
Update.
* mn10300-tdep.c (push_reg, check_for_saved)
(mn10300_analyze_prologue): Update.
* mep-tdep.c (is_arg_spill, check_for_saved)
(mep_analyze_prologue): Update.
* m32c-tdep.c (m32c_pv_push, m32c_srcdest_fetch)
(m32c_srcdest_store, m32c_pv_enter, m32c_is_arg_spill)
(m32c_is_struct_return, m32c_analyze_prologue): Update.
* arm-tdep.c (thumb_analyze_prologue, arm_analyze_prologue):
Update.
* arc-tdep.c (arc_is_in_prologue, arc_analyze_prologue): Update.
* aarch64-tdep.c (aarch64_analyze_prologue): Update.
2017-10-08 02:23:36 +02:00
|
|
|
stack.scan (check_for_saved, result);
|
2013-06-25 03:16:31 +02:00
|
|
|
|
|
|
|
result->prologue_end = after_last_frame_setup_insn;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "skip_prologue" gdbarch method. */
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
msp430_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
CORE_ADDR func_addr, func_end;
|
|
|
|
struct msp430_prologue p;
|
|
|
|
|
|
|
|
/* Try to find the extent of the function that contains PC. */
|
|
|
|
if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
|
|
|
|
return pc;
|
|
|
|
|
|
|
|
msp430_analyze_prologue (gdbarch, pc, func_end, &p);
|
|
|
|
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
|
|
|
|
return that struct as the value of this function. */
|
|
|
|
|
|
|
|
static struct msp430_prologue *
|
|
|
|
msp430_analyze_frame_prologue (struct frame_info *this_frame,
|
|
|
|
void **this_prologue_cache)
|
|
|
|
{
|
|
|
|
if (!*this_prologue_cache)
|
|
|
|
{
|
|
|
|
CORE_ADDR func_start, stop_addr;
|
|
|
|
|
|
|
|
*this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct msp430_prologue);
|
|
|
|
|
|
|
|
func_start = get_frame_func (this_frame);
|
|
|
|
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. */
|
|
|
|
if (!func_start)
|
|
|
|
stop_addr = func_start;
|
|
|
|
|
|
|
|
msp430_analyze_prologue (get_frame_arch (this_frame), func_start,
|
2015-09-25 20:08:07 +02:00
|
|
|
stop_addr,
|
|
|
|
(struct msp430_prologue *) *this_prologue_cache);
|
2013-06-25 03:16:31 +02:00
|
|
|
}
|
|
|
|
|
2015-09-25 20:08:07 +02:00
|
|
|
return (struct msp430_prologue *) *this_prologue_cache;
|
2013-06-25 03:16:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Given a frame and a prologue cache, return this frame's base. */
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
msp430_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
|
|
|
|
{
|
|
|
|
struct msp430_prologue *p
|
|
|
|
= msp430_analyze_frame_prologue (this_frame, this_prologue_cache);
|
|
|
|
CORE_ADDR sp = get_frame_register_unsigned (this_frame, MSP430_SP_REGNUM);
|
|
|
|
|
|
|
|
return sp - p->frame_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "frame_this_id" method for unwinding frames. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
msp430_this_id (struct frame_info *this_frame,
|
|
|
|
void **this_prologue_cache, struct frame_id *this_id)
|
|
|
|
{
|
|
|
|
*this_id = frame_id_build (msp430_frame_base (this_frame,
|
|
|
|
this_prologue_cache),
|
|
|
|
get_frame_func (this_frame));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "frame_prev_register" method for unwinding frames. */
|
|
|
|
|
|
|
|
static struct value *
|
|
|
|
msp430_prev_register (struct frame_info *this_frame,
|
|
|
|
void **this_prologue_cache, int regnum)
|
|
|
|
{
|
|
|
|
struct msp430_prologue *p
|
|
|
|
= msp430_analyze_frame_prologue (this_frame, this_prologue_cache);
|
|
|
|
CORE_ADDR frame_base = msp430_frame_base (this_frame, this_prologue_cache);
|
|
|
|
|
|
|
|
if (regnum == MSP430_SP_REGNUM)
|
|
|
|
return frame_unwind_got_constant (this_frame, regnum, frame_base);
|
|
|
|
|
|
|
|
/* If prologue analysis says we saved this register somewhere,
|
|
|
|
return a description of the stack slot holding it. */
|
|
|
|
else if (p->reg_offset[regnum] != 1)
|
|
|
|
{
|
|
|
|
struct value *rv = frame_unwind_got_memory (this_frame, regnum,
|
|
|
|
frame_base +
|
|
|
|
p->reg_offset[regnum]);
|
|
|
|
|
|
|
|
if (regnum == MSP430_PC_REGNUM)
|
|
|
|
{
|
|
|
|
ULONGEST pc = value_as_long (rv);
|
|
|
|
|
|
|
|
return frame_unwind_got_constant (this_frame, regnum, pc);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Otherwise, presume we haven't changed the value of this
|
|
|
|
register, and get it from the next frame. */
|
|
|
|
else
|
|
|
|
return frame_unwind_got_register (this_frame, regnum, regnum);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct frame_unwind msp430_unwind = {
|
|
|
|
NORMAL_FRAME,
|
|
|
|
default_frame_unwind_stop_reason,
|
|
|
|
msp430_this_id,
|
|
|
|
msp430_prev_register,
|
|
|
|
NULL,
|
|
|
|
default_frame_sniffer
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Implement the "dwarf2_reg_to_regnum" gdbarch method. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
msp430_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int reg)
|
|
|
|
{
|
2015-10-27 00:05:21 +01:00
|
|
|
if (reg >= 0 && reg < MSP430_NUM_REGS)
|
2013-06-25 03:16:31 +02:00
|
|
|
return reg + MSP430_NUM_REGS;
|
2015-10-27 00:05:21 +01:00
|
|
|
return -1;
|
2013-06-25 03:16:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "return_value" gdbarch method. */
|
|
|
|
|
|
|
|
static enum return_value_convention
|
|
|
|
msp430_return_value (struct gdbarch *gdbarch,
|
|
|
|
struct value *function,
|
|
|
|
struct type *valtype,
|
|
|
|
struct regcache *regcache,
|
|
|
|
gdb_byte *readbuf, const gdb_byte *writebuf)
|
|
|
|
{
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
LONGEST valtype_len = TYPE_LENGTH (valtype);
|
|
|
|
int code_model = gdbarch_tdep (gdbarch)->code_model;
|
|
|
|
|
|
|
|
if (TYPE_LENGTH (valtype) > 8
|
|
|
|
|| TYPE_CODE (valtype) == TYPE_CODE_STRUCT
|
|
|
|
|| TYPE_CODE (valtype) == TYPE_CODE_UNION)
|
|
|
|
return RETURN_VALUE_STRUCT_CONVENTION;
|
|
|
|
|
|
|
|
if (readbuf)
|
|
|
|
{
|
|
|
|
ULONGEST u;
|
|
|
|
int argreg = MSP430_R12_REGNUM;
|
|
|
|
int offset = 0;
|
|
|
|
|
|
|
|
while (valtype_len > 0)
|
|
|
|
{
|
|
|
|
int size = 2;
|
|
|
|
|
|
|
|
if (code_model == MSP_LARGE_CODE_MODEL
|
|
|
|
&& TYPE_CODE (valtype) == TYPE_CODE_PTR)
|
|
|
|
{
|
|
|
|
size = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
regcache_cooked_read_unsigned (regcache, argreg, &u);
|
|
|
|
store_unsigned_integer (readbuf + offset, size, byte_order, u);
|
|
|
|
valtype_len -= size;
|
|
|
|
offset += size;
|
|
|
|
argreg++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (writebuf)
|
|
|
|
{
|
|
|
|
ULONGEST u;
|
|
|
|
int argreg = MSP430_R12_REGNUM;
|
|
|
|
int offset = 0;
|
|
|
|
|
|
|
|
while (valtype_len > 0)
|
|
|
|
{
|
|
|
|
int size = 2;
|
|
|
|
|
|
|
|
if (code_model == MSP_LARGE_CODE_MODEL
|
|
|
|
&& TYPE_CODE (valtype) == TYPE_CODE_PTR)
|
|
|
|
{
|
|
|
|
size = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
u = extract_unsigned_integer (writebuf + offset, size, byte_order);
|
|
|
|
regcache_cooked_write_unsigned (regcache, argreg, u);
|
|
|
|
valtype_len -= size;
|
|
|
|
offset += size;
|
|
|
|
argreg++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return RETURN_VALUE_REGISTER_CONVENTION;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Implement the "frame_align" gdbarch method. */
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
msp430_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
|
|
|
|
{
|
|
|
|
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,
|
2018-11-16 12:21:04 +01:00
|
|
|
function_call_return_method return_method,
|
|
|
|
CORE_ADDR struct_addr)
|
2013-06-25 03:16:31 +02:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
|
|
|
struct type *func_type = value_type (function);
|
|
|
|
|
|
|
|
/* Dereference function pointer types. */
|
|
|
|
while (TYPE_CODE (func_type) == 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);
|
|
|
|
|
|
|
|
/* We make two passes; the first does the stack allocation,
|
|
|
|
the second actually stores the arguments. */
|
|
|
|
for (write_pass = 0; write_pass <= 1; write_pass++)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int arg_reg = MSP430_R12_REGNUM;
|
|
|
|
int args_on_stack = 0;
|
|
|
|
|
|
|
|
if (write_pass)
|
|
|
|
sp = align_down (sp - sp_off, 4);
|
|
|
|
sp_off = 0;
|
|
|
|
|
2018-11-16 12:21:04 +01:00
|
|
|
if (return_method == return_method_struct)
|
2013-06-25 03:16:31 +02:00
|
|
|
{
|
|
|
|
if (write_pass)
|
|
|
|
regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);
|
|
|
|
arg_reg++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Push the arguments. */
|
|
|
|
for (i = 0; i < nargs; i++)
|
|
|
|
{
|
|
|
|
struct value *arg = args[i];
|
|
|
|
const gdb_byte *arg_bits = value_contents_all (arg);
|
|
|
|
struct type *arg_type = check_typedef (value_type (arg));
|
|
|
|
ULONGEST arg_size = TYPE_LENGTH (arg_type);
|
|
|
|
int offset;
|
|
|
|
int current_arg_on_stack;
|
2018-04-22 06:42:00 +02:00
|
|
|
gdb_byte struct_addr_buf[4];
|
2013-06-25 03:16:31 +02:00
|
|
|
|
|
|
|
current_arg_on_stack = 0;
|
|
|
|
|
|
|
|
if (TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
|
|
|
|
|| TYPE_CODE (arg_type) == TYPE_CODE_UNION)
|
|
|
|
{
|
|
|
|
/* Aggregates of any size are passed by reference. */
|
2018-04-22 06:42:00 +02:00
|
|
|
store_unsigned_integer (struct_addr_buf, 4, byte_order,
|
2013-06-25 03:16:31 +02:00
|
|
|
value_address (arg));
|
2018-04-22 06:42:00 +02:00
|
|
|
arg_bits = struct_addr_buf;
|
2013-06-25 03:16:31 +02:00
|
|
|
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. */
|
|
|
|
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. */
|
|
|
|
if (!current_arg_on_stack
|
|
|
|
&& (arg_reg
|
|
|
|
+ ((arg_size == 8 || args_on_stack)
|
|
|
|
? ((arg_size - offset) / 2 - 1)
|
|
|
|
: 0) <= MSP430_R15_REGNUM))
|
|
|
|
{
|
|
|
|
int size = 2;
|
|
|
|
|
|
|
|
if (code_model == MSP_LARGE_CODE_MODEL
|
2015-09-30 01:31:48 +02:00
|
|
|
&& (TYPE_CODE (arg_type) == TYPE_CODE_PTR
|
Convert lvalue reference type check to general reference type check
In almost all contexts (except for overload resolution rules and expression
semantics), lvalue and rvalue references are equivalent. That means that in all
but these cases we can replace a TYPE_CODE_REF check to a TYPE_IS_REFERENCE
check and, for switch statements, add a case label for a rvalue reference type
next to a case label for an lvalue reference type. This patch does exactly
that.
gdb/ChangeLog
PR gdb/14441
* aarch64-tdep.c (aarch64_type_align)
(aarch64_extract_return_value, aarch64_store_return_value): Change
lvalue reference type checks to general reference type checks.
* amd64-tdep.c (amd64_classify): Likewise.
* amd64-windows-tdep.c (amd64_windows_passed_by_integer_register):
Likewise.
* arm-tdep.c (arm_type_align, arm_extract_return_value)
(arm_store_return_value): Likewise.
* ax-gdb.c (gen_fetch, gen_cast): Likewise.
* c-typeprint.c (c_print_type): Likewise.
* c-varobj.c (adjust_value_for_child_access, c_value_of_variable)
(cplus_number_of_children, cplus_describe_child): Likewise.
* compile/compile-c-symbols.c (generate_vla_size): Likewise.
* completer.c (expression_completer): Likewise.
* cp-support.c (make_symbol_overload_list_adl_namespace):
Likewise.
* darwin-nat-info.c (info_mach_region_command): Likewise.
* dwarf2loc.c (entry_data_value_coerce_ref)
(value_of_dwarf_reg_entry): Likewise.
* eval.c (ptrmath_type_p, evaluate_subexp_standard)
(evaluate_subexp_for_address, evaluate_subexp_for_sizeof):
Likewise.
* findvar.c (extract_typed_address, store_typed_address):
Likewise.
* gdbtypes.c (rank_one_type): Likewise.
* hppa-tdep.c (hppa64_integral_or_pointer_p): Likewise.
* infcall.c (value_arg_coerce): Likewise.
* language.c (pointer_type): Likewise.
* m32c-tdep.c (m32c_reg_arg_type, m32c_m16c_address_to_pointer):
Likewise.
* m88k-tdep.c (m88k_integral_or_pointer_p): Likewise.
* mn10300-tdep.c (mn10300_type_align): Likewise.
* msp430-tdep.c (msp430_push_dummy_call): Likewise.
* ppc-sysv-tdep.c (do_ppc_sysv_return_value)
(ppc64_sysv_abi_push_param, ppc64_sysv_abi_return_value):
Likewise.
* printcmd.c (print_formatted, x_command): Likewise.
* python/py-type.c (typy_get_composite, typy_template_argument):
Likewise.
* python/py-value.c (valpy_referenced_value)
(valpy_get_dynamic_type, value_has_field): Likewise.
* s390-linux-tdep.c (s390_function_arg_integer): Likewise.
* sparc-tdep.c (sparc_integral_or_pointer_p): Likewise.
* sparc64-tdep.c (sparc64_integral_or_pointer_p): Likewise.
* spu-tdep.c (spu_scalar_value_p): Likewise.
* symtab.c (lookup_symbol_aux): Likewise.
* typeprint.c (whatis_exp, print_type_scalar): Likewise.
* valarith.c (binop_types_user_defined_p, unop_user_defined_p):
Likewise.
* valops.c (value_cast_pointers, value_cast)
(value_reinterpret_cast, value_dynamic_cast, value_addr, typecmp)
(value_struct_elt, value_struct_elt_bitpos)
(value_find_oload_method_list, find_overload_match)
(value_rtti_indirect_type): Likewise.
* valprint.c (val_print_scalar_type_p, generic_val_print):
Likewise.
* value.c (value_actual_type, value_as_address, unpack_long)
(pack_long, pack_unsigned_long, coerce_ref_if_computed)
(coerce_ref): Likewise.
* varobj.c (varobj_get_value_type): Likewise.
2017-03-20 21:47:54 +01:00
|
|
|
|| TYPE_IS_REFERENCE (arg_type)
|
2015-09-30 01:31:48 +02:00
|
|
|
|| TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
|
|
|
|
|| TYPE_CODE (arg_type) == TYPE_CODE_UNION))
|
2013-06-25 03:16:31 +02:00
|
|
|
{
|
2015-09-30 01:31:48 +02:00
|
|
|
/* When using the large memory model, pointer,
|
|
|
|
reference, struct, and union arguments are
|
|
|
|
passed using the entire register. (As noted
|
|
|
|
earlier, aggregates are always passed by
|
|
|
|
reference.) */
|
2013-06-25 03:16:31 +02:00
|
|
|
if (offset != 0)
|
|
|
|
continue;
|
|
|
|
size = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (write_pass)
|
|
|
|
regcache_cooked_write_unsigned (regcache, arg_reg,
|
|
|
|
extract_unsigned_integer
|
|
|
|
(arg_bits + offset, size,
|
|
|
|
byte_order));
|
|
|
|
|
|
|
|
arg_reg++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (write_pass)
|
|
|
|
write_memory (sp + sp_off, arg_bits + offset, 2);
|
|
|
|
|
|
|
|
sp_off += 2;
|
|
|
|
args_on_stack = 1;
|
|
|
|
current_arg_on_stack = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Keep track of the stack address prior to pushing the return address.
|
|
|
|
This is the value that we'll return. */
|
|
|
|
cfa = sp;
|
|
|
|
|
|
|
|
/* Push the return address. */
|
|
|
|
{
|
|
|
|
int sz = (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL)
|
|
|
|
? 2 : 4;
|
|
|
|
sp = sp - sz;
|
|
|
|
write_memory_unsigned_integer (sp, sz, byte_order, bp_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update the stack pointer. */
|
|
|
|
regcache_cooked_write_unsigned (regcache, MSP430_SP_REGNUM, sp);
|
|
|
|
|
|
|
|
return cfa;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* In order to keep code size small, the compiler may create epilogue
|
|
|
|
code through which more than one function epilogue is routed. I.e.
|
|
|
|
the epilogue and return may just be a branch to some common piece of
|
|
|
|
code which is responsible for tearing down the frame and performing
|
|
|
|
the return. These epilog (label) names will have the common prefix
|
|
|
|
defined here. */
|
|
|
|
|
|
|
|
static const char msp430_epilog_name_prefix[] = "__mspabi_func_epilog_";
|
|
|
|
|
|
|
|
/* Implement the "in_return_stub" gdbarch method. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
msp430_in_return_stub (struct gdbarch *gdbarch, CORE_ADDR pc,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
return (name != NULL
|
2015-03-06 10:42:06 +01:00
|
|
|
&& startswith (name, msp430_epilog_name_prefix));
|
2013-06-25 03:16:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "skip_trampoline_code" gdbarch method. */
|
|
|
|
static CORE_ADDR
|
|
|
|
msp430_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
|
|
|
|
{
|
|
|
|
struct bound_minimal_symbol bms;
|
|
|
|
const char *stub_name;
|
|
|
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
|
|
|
|
|
|
|
bms = lookup_minimal_symbol_by_pc (pc);
|
|
|
|
if (!bms.minsym)
|
|
|
|
return pc;
|
|
|
|
|
change minsym representation
In a later patch we're going to change the minimal symbol address
calculation to apply section offsets at the point of use. To make it
simpler to catch potential problem spots, this patch changes the
representation of minimal symbols and introduces new
minimal-symbol-specific variants of the various accessors. This is
necessary because it would be excessively ambitious to try to convert
all the symbol types at once.
The core of this change is just renaming a field in minimal_symbol;
the rest is just a fairly mechanical rewording.
2014-02-26 Tom Tromey <tromey@redhat.com>
* symtab.h (struct minimal_symbol) <mginfo>: Rename from ginfo.
(MSYMBOL_VALUE, MSYMBOL_VALUE_ADDRESS, MSYMBOL_VALUE_BYTES)
(MSYMBOL_BLOCK_VALUE, MSYMBOL_VALUE_CHAIN, MSYMBOL_LANGUAGE)
(MSYMBOL_SECTION, MSYMBOL_OBJ_SECTION, MSYMBOL_NATURAL_NAME)
(MSYMBOL_LINKAGE_NAME, MSYMBOL_PRINT_NAME, MSYMBOL_DEMANGLED_NAME)
(MSYMBOL_SET_LANGUAGE, MSYMBOL_SEARCH_NAME)
(MSYMBOL_MATCHES_SEARCH_NAME, MSYMBOL_SET_NAMES): New macros.
* ada-lang.c (ada_main_name): Update.
(ada_lookup_simple_minsym): Update.
(ada_make_symbol_completion_list): Update.
(ada_add_standard_exceptions): Update.
* ada-tasks.c (read_atcb, ada_tasks_inferior_data_sniffer): Update.
* aix-thread.c (pdc_symbol_addrs, pd_enable): Update.
* amd64-windows-tdep.c (amd64_skip_main_prologue): Update.
* arm-tdep.c (skip_prologue_function): Update.
(arm_skip_stack_protector, arm_skip_stub): Update.
* arm-wince-tdep.c (arm_pe_skip_trampoline_code): Update.
(arm_wince_skip_main_prologue): Update.
* auxv.c (ld_so_xfer_auxv): Update.
* avr-tdep.c (avr_scan_prologue): Update.
* ax-gdb.c (gen_var_ref): Update.
* block.c (call_site_for_pc): Update.
* blockframe.c (get_pc_function_start): Update.
(find_pc_partial_function_gnu_ifunc): Update.
* breakpoint.c (create_overlay_event_breakpoint): Update.
(create_longjmp_master_breakpoint): Update.
(create_std_terminate_master_breakpoint): Update.
(create_exception_master_breakpoint): Update.
(resolve_sal_pc): Update.
* bsd-uthread.c (bsd_uthread_lookup_address): Update.
* btrace.c (ftrace_print_function_name, ftrace_function_switched):
Update.
* c-valprint.c (c_val_print): Update.
* coff-pe-read.c (add_pe_forwarded_sym): Update.
* coffread.c (coff_symfile_read): Update.
* common/agent.c (agent_look_up_symbols): Update.
* dbxread.c (find_stab_function_addr): Update.
(end_psymtab): Update.
* dwarf2loc.c (call_site_to_target_addr): Update.
(func_verify_no_selftailcall): Update.
(tailcall_dump): Update.
(call_site_find_chain_1): Update.
(dwarf_expr_reg_to_entry_parameter): Update.
* elfread.c (elf_gnu_ifunc_record_cache): Update.
(elf_gnu_ifunc_resolve_by_got): Update.
* f-valprint.c (info_common_command): Update.
* findvar.c (read_var_value): Update.
* frame.c (get_prev_frame_1): Update.
(inside_main_func): Update.
* frv-tdep.c (frv_skip_main_prologue): Update.
(frv_frame_this_id): Update.
* glibc-tdep.c (glibc_skip_solib_resolver): Update.
* gnu-v2-abi.c (gnuv2_value_rtti_type): Update.
* gnu-v3-abi.c (gnuv3_rtti_type): Update.
(gnuv3_skip_trampoline): Update.
* hppa-hpux-tdep.c (hppa32_hpux_in_solib_call_trampoline): Update.
(hppa64_hpux_in_solib_call_trampoline): Update.
(hppa_hpux_skip_trampoline_code): Update.
(hppa64_hpux_search_dummy_call_sequence): Update.
(hppa_hpux_find_import_stub_for_addr): Update.
(hppa_hpux_find_dummy_bpaddr): Update.
* hppa-tdep.c (hppa_symbol_address)
(hppa_lookup_stub_minimal_symbol): Update.
* i386-tdep.c (i386_skip_main_prologue): Update.
(i386_pe_skip_trampoline_code): Update.
* ia64-tdep.c (ia64_convert_from_func_ptr_addr): Update.
* infcall.c (get_function_name): Update.
* infcmd.c (until_next_command): Update.
* jit.c (jit_breakpoint_re_set_internal): Update.
(jit_inferior_init): Update.
* linespec.c (minsym_found): Update.
(add_minsym): Update.
* linux-fork.c (info_checkpoints_command): Update.
* linux-nat.c (get_signo): Update.
* linux-thread-db.c (inferior_has_bug): Update.
* m32c-tdep.c (m32c_return_value): Update.
(m32c_m16c_address_to_pointer): Update.
(m32c_m16c_pointer_to_address): Update.
* m32r-tdep.c (m32r_frame_this_id): Update.
* m68hc11-tdep.c (m68hc11_get_register_info): Update.
* machoread.c (macho_resolve_oso_sym_with_minsym): Update.
* maint.c (maintenance_translate_address): Update.
* minsyms.c (add_minsym_to_hash_table): Update.
(add_minsym_to_demangled_hash_table): Update.
(msymbol_objfile): Update.
(lookup_minimal_symbol): Update.
(iterate_over_minimal_symbols): Update.
(lookup_minimal_symbol_text): Update.
(lookup_minimal_symbol_by_pc_name): Update.
(lookup_minimal_symbol_solib_trampoline): Update.
(lookup_minimal_symbol_by_pc_section_1): Update.
(lookup_minimal_symbol_and_objfile): Update.
(prim_record_minimal_symbol_full): Update.
(compare_minimal_symbols): Update.
(compact_minimal_symbols): Update.
(build_minimal_symbol_hash_tables): Update.
(install_minimal_symbols): Update.
(terminate_minimal_symbol_table): Update.
(find_solib_trampoline_target): Update.
(minimal_symbol_upper_bound): Update.
* mips-linux-tdep.c (mips_linux_skip_resolver): Update.
* mips-tdep.c (mips_stub_frame_sniffer): Update.
(mips_skip_pic_trampoline_code): Update.
* msp430-tdep.c (msp430_skip_trampoline_code): Update.
* objc-lang.c (selectors_info): Update.
(classes_info): Update.
(find_methods): Update.
(find_imps): Update.
(find_objc_msgsend): Update.
* objfiles.c (objfile_relocate1): Update.
* objfiles.h (ALL_OBJFILE_MSYMBOLS): Update.
* obsd-tdep.c (obsd_skip_solib_resolver): Update.
* p-valprint.c (pascal_val_print): Update.
* parse.c (write_exp_msymbol): Update.
* ppc-linux-tdep.c (powerpc_linux_in_dynsym_resolve_code)
(ppc_linux_spe_context_lookup, ppc_elfv2_skip_entrypoint): Update.
* ppc-sysv-tdep.c (convert_code_addr_to_desc_addr): Update.
* printcmd.c (build_address_symbolic): Update.
(sym_info): Update.
(address_info): Update.
* proc-service.c (ps_pglobal_lookup): Update.
* psymtab.c (find_pc_sect_psymtab_closer): Update.
(find_pc_sect_psymtab): Update.
* python/py-framefilter.c (py_print_frame): Update.
* ravenscar-thread.c (get_running_thread_id): Update.
* record-btrace.c (btrace_call_history, btrace_get_bfun_name):
Update.
* remote.c (remote_check_symbols): Update.
* rs6000-tdep.c (rs6000_skip_main_prologue): Update.
(rs6000_skip_trampoline_code): Update.
* sh64-tdep.c (sh64_elf_make_msymbol_special): Update.
* sol2-tdep.c (sol2_skip_solib_resolver): Update.
* solib-dsbt.c (lm_base): Update.
* solib-frv.c (lm_base): Update.
(main_got): Update.
* solib-irix.c (locate_base): Update.
* solib-som.c (som_solib_create_inferior_hook): Update.
(som_solib_desire_dynamic_linker_symbols): Update.
(link_map_start): Update.
* solib-spu.c (spu_enable_break): Update.
(ocl_enable_break): Update.
* solib-svr4.c (elf_locate_base): Update.
(enable_break): Update.
* spu-tdep.c (spu_get_overlay_table): Update.
(spu_catch_start): Update.
(flush_ea_cache): Update.
* stabsread.c (define_symbol): Update.
(scan_file_globals): Update.
* stack.c (find_frame_funname): Update.
(frame_info): Update.
* symfile.c (simple_read_overlay_table): Update.
(simple_overlay_update): Update.
* symmisc.c (dump_msymbols): Update.
* symtab.c (fixup_section): Update.
(find_pc_sect_line): Update.
(skip_prologue_sal): Update.
(search_symbols): Update.
(print_msymbol_info): Update.
(rbreak_command): Update.
(MCOMPLETION_LIST_ADD_SYMBOL): New macro.
(completion_list_objc_symbol): Update.
(default_make_symbol_completion_list_break_on): Update.
* tracepoint.c (scope_info): Update.
* tui/tui-disasm.c (tui_find_disassembly_address): Update.
(tui_get_begin_asm_address): Update.
* valops.c (find_function_in_inferior): Update.
* value.c (value_static_field): Update.
(value_fn_field): Update.
2013-08-15 16:43:43 +02:00
|
|
|
stub_name = MSYMBOL_LINKAGE_NAME (bms.minsym);
|
2013-06-25 03:16:31 +02:00
|
|
|
|
|
|
|
if (gdbarch_tdep (gdbarch)->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);
|
|
|
|
|
|
|
|
return read_memory_integer
|
|
|
|
(sp + 2 * (stub_name[strlen (msp430_epilog_name_prefix)] - '0'),
|
|
|
|
2, gdbarch_byte_order (gdbarch));
|
|
|
|
}
|
|
|
|
|
|
|
|
return pc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate and initialize a gdbarch object. */
|
|
|
|
|
|
|
|
static struct gdbarch *
|
|
|
|
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. */
|
|
|
|
if (info.abfd != NULL
|
|
|
|
&& bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
|
|
|
|
elf_flags = elf_elfheader (info.abfd)->e_flags;
|
|
|
|
else
|
|
|
|
elf_flags = 0;
|
|
|
|
|
|
|
|
if (info.abfd != NULL)
|
|
|
|
switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
|
|
|
|
OFBA_MSPABI_Tag_ISA))
|
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
isa = MSP_ISA_MSP430;
|
|
|
|
code_model = MSP_SMALL_CODE_MODEL;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
isa = MSP_ISA_MSP430X;
|
|
|
|
switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
|
|
|
|
OFBA_MSPABI_Tag_Code_Model))
|
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
code_model = MSP_SMALL_CODE_MODEL;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
code_model = MSP_LARGE_CODE_MODEL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
_("Unknown msp430x code memory model"));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
/* This can happen when loading a previously dumped data structure.
|
|
|
|
Use the ISA and code model from the current architecture, provided
|
|
|
|
it's compatible. */
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
|
|
|
|
elf_flags = ca_tdep->elf_flags;
|
|
|
|
isa = ca_tdep->isa;
|
|
|
|
code_model = ca_tdep->code_model;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-09-27 19:18:04 +02:00
|
|
|
/* Fall through. */
|
2013-06-25 03:16:31 +02:00
|
|
|
default:
|
|
|
|
error (_("Unknown msp430 isa"));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
isa = MSP_ISA_MSP430;
|
|
|
|
code_model = MSP_SMALL_CODE_MODEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Try to find the architecture in the list of already defined
|
|
|
|
architectures. */
|
|
|
|
for (arches = gdbarch_list_lookup_by_info (arches, &info);
|
|
|
|
arches != NULL;
|
|
|
|
arches = gdbarch_list_lookup_by_info (arches->next, &info))
|
|
|
|
{
|
|
|
|
struct gdbarch_tdep *candidate_tdep = gdbarch_tdep (arches->gdbarch);
|
|
|
|
|
|
|
|
if (candidate_tdep->elf_flags != elf_flags
|
|
|
|
|| candidate_tdep->isa != isa
|
|
|
|
|| candidate_tdep->code_model != code_model)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return arches->gdbarch;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* None found, create a new architecture from the information
|
|
|
|
provided. */
|
2017-05-24 23:15:23 +02:00
|
|
|
tdep = XCNEW (struct gdbarch_tdep);
|
2013-06-25 03:16:31 +02:00
|
|
|
gdbarch = gdbarch_alloc (&info, tdep);
|
|
|
|
tdep->elf_flags = elf_flags;
|
|
|
|
tdep->isa = isa;
|
|
|
|
tdep->code_model = code_model;
|
|
|
|
|
|
|
|
/* Registers. */
|
|
|
|
set_gdbarch_num_regs (gdbarch, MSP430_NUM_REGS);
|
|
|
|
set_gdbarch_num_pseudo_regs (gdbarch, MSP430_NUM_PSEUDO_REGS);
|
|
|
|
set_gdbarch_register_name (gdbarch, msp430_register_name);
|
|
|
|
if (isa == MSP_ISA_MSP430)
|
|
|
|
set_gdbarch_register_type (gdbarch, msp430_register_type);
|
|
|
|
else
|
|
|
|
set_gdbarch_register_type (gdbarch, msp430x_register_type);
|
|
|
|
set_gdbarch_pc_regnum (gdbarch, MSP430_PC_REGNUM);
|
|
|
|
set_gdbarch_sp_regnum (gdbarch, MSP430_SP_REGNUM);
|
|
|
|
set_gdbarch_register_reggroup_p (gdbarch, msp430_register_reggroup_p);
|
|
|
|
set_gdbarch_pseudo_register_read (gdbarch, msp430_pseudo_register_read);
|
|
|
|
set_gdbarch_pseudo_register_write (gdbarch, msp430_pseudo_register_write);
|
|
|
|
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, msp430_dwarf2_reg_to_regnum);
|
|
|
|
set_gdbarch_register_sim_regno (gdbarch, msp430_register_sim_regno);
|
|
|
|
|
|
|
|
/* Data types. */
|
|
|
|
set_gdbarch_char_signed (gdbarch, 0);
|
|
|
|
set_gdbarch_short_bit (gdbarch, 16);
|
|
|
|
set_gdbarch_int_bit (gdbarch, 16);
|
|
|
|
set_gdbarch_long_bit (gdbarch, 32);
|
|
|
|
set_gdbarch_long_long_bit (gdbarch, 64);
|
|
|
|
if (code_model == MSP_SMALL_CODE_MODEL)
|
|
|
|
{
|
|
|
|
set_gdbarch_ptr_bit (gdbarch, 16);
|
|
|
|
set_gdbarch_addr_bit (gdbarch, 16);
|
|
|
|
}
|
|
|
|
else /* MSP_LARGE_CODE_MODEL */
|
|
|
|
{
|
|
|
|
set_gdbarch_ptr_bit (gdbarch, 32);
|
|
|
|
set_gdbarch_addr_bit (gdbarch, 32);
|
|
|
|
}
|
|
|
|
set_gdbarch_dwarf2_addr_size (gdbarch, 4);
|
|
|
|
set_gdbarch_float_bit (gdbarch, 32);
|
|
|
|
set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
|
|
|
|
set_gdbarch_double_bit (gdbarch, 64);
|
|
|
|
set_gdbarch_long_double_bit (gdbarch, 64);
|
|
|
|
set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
|
|
|
|
set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
|
|
|
|
|
|
|
|
/* Breakpoints. */
|
2016-11-03 15:35:14 +01:00
|
|
|
set_gdbarch_breakpoint_kind_from_pc (gdbarch,
|
|
|
|
msp430_breakpoint::kind_from_pc);
|
|
|
|
set_gdbarch_sw_breakpoint_from_kind (gdbarch,
|
|
|
|
msp430_breakpoint::bp_from_kind);
|
2013-06-25 03:16:31 +02:00
|
|
|
set_gdbarch_decr_pc_after_break (gdbarch, 1);
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
|
|
|
/* Trampolines. */
|
|
|
|
set_gdbarch_in_solib_return_trampoline (gdbarch, msp430_in_return_stub);
|
|
|
|
set_gdbarch_skip_trampoline_code (gdbarch, msp430_skip_trampoline_code);
|
|
|
|
|
|
|
|
/* Virtual tables. */
|
|
|
|
set_gdbarch_vbit_in_delta (gdbarch, 0);
|
|
|
|
|
|
|
|
return gdbarch;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Register the initialization routine. */
|
|
|
|
|
|
|
|
void
|
|
|
|
_initialize_msp430_tdep (void)
|
|
|
|
{
|
|
|
|
register_gdbarch_init (bfd_arch_msp430, msp430_gdbarch_init);
|
|
|
|
}
|