/* Target-dependent code for UltraSPARC.
- Copyright (C) 2003-2018 Free Software Foundation, Inc.
+ Copyright (C) 2003-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "arch-utils.h"
-#include "dwarf2-frame.h"
+#include "dwarf2/frame.h"
#include "frame.h"
#include "frame-base.h"
#include "frame-unwind.h"
#include "target-descriptions.h"
#include "target.h"
#include "value.h"
-
#include "sparc64-tdep.h"
+#include <forward_list>
/* This file implements the SPARC 64-bit ABI as defined by the
section "Low-Level System Information" of the SPARC Compliance
static struct cmd_list_element *sparc64adilist = NULL;
/* ADI stat settings. */
-typedef struct
+struct adi_stat_t
{
/* The ADI block size. */
unsigned long blksize;
/* ADI is available. */
bool is_avail = false;
-} adi_stat_t;
+};
/* Per-process ADI stat info. */
-typedef struct sparc64_adi_info
+struct sparc64_adi_info
{
sparc64_adi_info (pid_t pid_)
: pid (pid_)
/* The ADI stat. */
adi_stat_t stat = {};
-} sparc64_adi_info;
+};
static std::forward_list<sparc64_adi_info> adi_proc_list;
get_adi_info_proc (pid_t pid)
{
auto found = std::find_if (adi_proc_list.begin (), adi_proc_list.end (),
- [&pid] (const sparc64_adi_info &info)
- {
- return info.pid == pid;
- });
+ [&pid] (const sparc64_adi_info &info)
+ {
+ return info.pid == pid;
+ });
if (found == adi_proc_list.end ())
{
{
if ((*it).pid == pid)
{
- if ((*it).stat.tag_fd > 0)
- target_fileio_close ((*it).stat.tag_fd, &target_errno);
+ if ((*it).stat.tag_fd > 0)
+ target_fileio_close ((*it).stat.tag_fd, &target_errno);
adi_proc_list.erase_after (pit);
- break;
+ break;
}
else
pit = it++;
}
-static void
-info_adi_command (const char *args, int from_tty)
-{
- printf_unfiltered ("\"adi\" must be followed by \"examine\" "
- "or \"assign\".\n");
- help_list (sparc64adilist, "adi ", all_commands, gdb_stdout);
-}
-
/* Read attributes of a maps entry in /proc/[pid]/adi/maps. */
static void
read_maps_entry (const char *line,
- ULONGEST *addr, ULONGEST *endaddr)
+ ULONGEST *addr, ULONGEST *endaddr)
{
const char *p = line;
static bool
adi_available (void)
{
- pid_t pid = ptid_get_pid (inferior_ptid);
+ pid_t pid = inferior_ptid.pid ();
sparc64_adi_info *proc = get_adi_info_proc (pid);
CORE_ADDR value;
return proc->stat.is_avail;
proc->stat.checked_avail = true;
- if (target_auxv_search (target_stack, AT_ADI_BLKSZ, &value) <= 0)
+ if (target_auxv_search (current_inferior ()->top_target (),
+ AT_ADI_BLKSZ, &value) <= 0)
return false;
proc->stat.blksize = value;
- target_auxv_search (target_stack, AT_ADI_NBITS, &value);
+ target_auxv_search (current_inferior ()->top_target (),
+ AT_ADI_NBITS, &value);
proc->stat.nbits = value;
proc->stat.max_version = (1 << proc->stat.nbits) - 2;
proc->stat.is_avail = true;
static CORE_ADDR
adi_normalize_address (CORE_ADDR addr)
{
- adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+ adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
if (ast.nbits)
{
static CORE_ADDR
adi_align_address (CORE_ADDR naddr)
{
- adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+ adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
return (naddr - (naddr % ast.blksize)) / ast.blksize;
}
static int
adi_convert_byte_count (CORE_ADDR naddr, int nbytes, CORE_ADDR locl)
{
- adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+ adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
return ((naddr + nbytes + ast.blksize - 1) / ast.blksize) - locl;
}
static int
adi_tag_fd (void)
{
- pid_t pid = ptid_get_pid (inferior_ptid);
+ pid_t pid = inferior_ptid.pid ();
sparc64_adi_info *proc = get_adi_info_proc (pid);
if (proc->stat.tag_fd != 0)
snprintf (cl_name, sizeof(cl_name), "/proc/%ld/adi/tags", (long) pid);
int target_errno;
proc->stat.tag_fd = target_fileio_open (NULL, cl_name, O_RDWR|O_EXCL,
- 0, &target_errno);
+ false, 0, &target_errno);
return proc->stat.tag_fd;
}
char filename[MAX_PROC_NAME_SIZE];
size_t i = 0;
- pid_t pid = ptid_get_pid (inferior_ptid);
+ pid_t pid = inferior_ptid.pid ();
snprintf (filename, sizeof filename, "/proc/%ld/adi/maps", (long) pid);
gdb::unique_xmalloc_ptr<char> data
= target_fileio_read_stralloc (NULL, filename);
if (data)
{
adi_stat_t adi_stat = get_adi_info (pid);
- char *line;
- for (line = strtok (data.get (), "\n"); line; line = strtok (NULL, "\n"))
- {
- ULONGEST addr, endaddr;
+ char *saveptr;
+ for (char *line = strtok_r (data.get (), "\n", &saveptr);
+ line;
+ line = strtok_r (NULL, "\n", &saveptr))
+ {
+ ULONGEST addr, endaddr;
- read_maps_entry (line, &addr, &endaddr);
+ read_maps_entry (line, &addr, &endaddr);
- while (((vaddr + i) * adi_stat.blksize) >= addr
- && ((vaddr + i) * adi_stat.blksize) < endaddr)
- {
- if (++i == cnt)
+ while (((vaddr + i) * adi_stat.blksize) >= addr
+ && ((vaddr + i) * adi_stat.blksize) < endaddr)
+ {
+ if (++i == cnt)
return true;
- }
- }
+ }
+ }
}
- else
- warning (_("unable to open /proc file '%s'"), filename);
+ else
+ warning (_("unable to open /proc file '%s'"), filename);
return false;
}
if (!adi_is_addr_mapped (vaddr, size))
{
- adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+ adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
error(_("Address at %s is not in ADI maps"),
- paddress (target_gdbarch (), vaddr * ast.blksize));
+ paddress (target_gdbarch (), vaddr * ast.blksize));
}
int target_errno;
if (!adi_is_addr_mapped (vaddr, size))
{
- adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+ adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
error(_("Address at %s is not in ADI maps"),
- paddress (target_gdbarch (), vaddr * ast.blksize));
+ paddress (target_gdbarch (), vaddr * ast.blksize));
}
int target_errno;
int v_idx = 0;
const int maxelts = 8; /* # of elements per line */
- adi_stat_t adi_stat = get_adi_info (ptid_get_pid (inferior_ptid));
+ adi_stat_t adi_stat = get_adi_info (inferior_ptid.pid ());
while (cnt > 0)
{
QUIT;
- printf_filtered ("%s:\t",
- paddress (target_gdbarch (), vaddr * adi_stat.blksize));
+ gdb_printf ("%s:\t",
+ paddress (target_gdbarch (), vaddr * adi_stat.blksize));
for (int i = maxelts; i > 0 && cnt > 0; i--, cnt--)
- {
- if (tags[v_idx] == 0xff) /* no version tag */
- printf_filtered ("-");
- else
- printf_filtered ("%1X", tags[v_idx]);
+ {
+ if (tags[v_idx] == 0xff) /* no version tag */
+ gdb_printf ("-");
+ else
+ gdb_printf ("%1X", tags[v_idx]);
if (cnt > 1)
- printf_filtered (" ");
- ++v_idx;
- }
- printf_filtered ("\n");
- gdb_flush (gdb_stdout);
+ gdb_printf (" ");
+ ++v_idx;
+ }
+ gdb_printf ("\n");
vaddr += maxelts;
}
}
Command syntax:
- adi (examine|x)/count <addr> */
+ adi (examine|x)[/COUNT] [ADDR] */
static void
adi_examine_command (const char *args, int from_tty)
{
/* make sure program is active and adi is available */
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("ADI command requires a live process/thread"));
if (!adi_available ())
error (_("No ADI information"));
- pid_t pid = ptid_get_pid (inferior_ptid);
- sparc64_adi_info *proc = get_adi_info_proc (pid);
int cnt = 1;
const char *p = args;
if (p && *p == '/')
if (p != 0 && *p != 0)
next_address = parse_and_eval_address (p);
if (!cnt || !next_address)
- error (_("Usage: adi examine|x[/count] <addr>"));
+ error (_("Usage: adi examine|x[/COUNT] [ADDR]"));
do_examine (next_address, cnt);
}
Command syntax:
- adi (assign|a)/count <addr> = <version> */
+ adi (assign|a)[/COUNT] ADDR = VERSION */
static void
adi_assign_command (const char *args, int from_tty)
{
+ static const char *adi_usage
+ = N_("Usage: adi assign|a[/COUNT] ADDR = VERSION");
+
/* make sure program is active and adi is available */
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("ADI command requires a live process/thread"));
if (!adi_available ())
const char *exp = args;
if (exp == 0)
- error_no_arg (_("Usage: adi assign|a[/count] <addr> = <version>"));
+ error_no_arg (_(adi_usage));
char *q = (char *) strchr (exp, '=');
if (q)
*q++ = 0;
else
- error (_("Usage: adi assign|a[/count] <addr> = <version>"));
+ error ("%s", _(adi_usage));
size_t cnt = 1;
const char *p = args;
if (p != 0 && *p != 0)
next_address = parse_and_eval_address (p);
else
- error (_("Usage: adi assign|a[/count] <addr> = <version>"));
+ error ("%s", _(adi_usage));
int version = 0;
if (q != NULL) /* parse version tag */
{
- adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+ adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
version = parse_and_eval_long (q);
if (version < 0 || version > ast.max_version)
- error (_("Invalid ADI version tag %d"), version);
+ error (_("Invalid ADI version tag %d"), version);
}
do_assign (next_address, cnt, version);
}
+void _initialize_sparc64_adi_tdep ();
void
-_initialize_sparc64_adi_tdep (void)
+_initialize_sparc64_adi_tdep ()
{
-
- add_prefix_cmd ("adi", class_support, info_adi_command,
- _("ADI version related commands."),
- &sparc64adilist, "adi ", 0, &cmdlist);
- add_cmd ("examine", class_support, adi_examine_command,
- _("Examine ADI versions."), &sparc64adilist);
- add_alias_cmd ("x", "examine", no_class, 1, &sparc64adilist);
+ add_basic_prefix_cmd ("adi", class_support,
+ _("ADI version related commands."),
+ &sparc64adilist, 0, &cmdlist);
+ cmd_list_element *adi_examine_cmd
+ = add_cmd ("examine", class_support, adi_examine_command,
+ _("Examine ADI versions."), &sparc64adilist);
+ add_alias_cmd ("x", adi_examine_cmd, no_class, 1, &sparc64adilist);
add_cmd ("assign", class_support, adi_assign_command,
- _("Assign ADI versions."), &sparc64adilist);
+ _("Assign ADI versions."), &sparc64adilist);
}
\f
static int
sparc64_integral_or_pointer_p (const struct type *type)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_INT:
case TYPE_CODE_BOOL:
static int
sparc64_floating_p (const struct type *type)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_FLT:
{
static int
sparc64_complex_floating_p (const struct type *type)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_COMPLEX:
{
static int
sparc64_structure_or_union_p (const struct type *type)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
static struct type *
sparc64_pstate_type (struct gdbarch *gdbarch)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
if (!tdep->sparc64_pstate_type)
{
static struct type *
sparc64_ccr_type (struct gdbarch *gdbarch)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
if (tdep->sparc64_ccr_type == NULL)
{
static struct type *
sparc64_fsr_type (struct gdbarch *gdbarch)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
if (!tdep->sparc64_fsr_type)
{
static struct type *
sparc64_fprs_type (struct gdbarch *gdbarch)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
if (!tdep->sparc64_fprs_type)
{
"fprs", \
"y"
-static const char *sparc64_fpu_register_names[] = { SPARC64_FPU_REGISTERS };
-static const char *sparc64_cp0_register_names[] = { SPARC64_CP0_REGISTERS };
+static const char * const sparc64_fpu_register_names[] = {
+ SPARC64_FPU_REGISTERS
+};
+static const char * const sparc64_cp0_register_names[] = {
+ SPARC64_CP0_REGISTERS
+};
-static const char *sparc64_register_names[] =
+static const char * const sparc64_register_names[] =
{
SPARC_CORE_REGISTERS,
SPARC64_FPU_REGISTERS,
/* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
registers as "psuedo" registers. */
-static const char *sparc64_pseudo_register_names[] =
+static const char * const sparc64_pseudo_register_names[] =
{
"cwp", "pstate", "asi", "ccr",
return sparc64_pseudo_register_names[regnum];
internal_error (__FILE__, __LINE__,
- _("sparc64_pseudo_register_name: bad register number %d"),
- regnum);
+ _("sparc64_pseudo_register_name: bad register number %d"),
+ regnum);
}
/* Return the name of register REGNUM. */
return builtin_type (gdbarch)->builtin_long_double;
internal_error (__FILE__, __LINE__,
- _("sparc64_pseudo_register_type: bad register number %d"),
- regnum);
+ _("sparc64_pseudo_register_type: bad register number %d"),
+ regnum);
}
/* Return the GDB type object for the "standard" data type of data in
if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
{
- CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
- ULONGEST i7;
+ CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
+ ULONGEST i7;
- /* Read the value in from memory. */
- i7 = get_frame_memory_unsigned (this_frame, addr, 8);
- return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);
+ /* Read the value in from memory. */
+ i7 = get_frame_memory_unsigned (this_frame, addr, 8);
+ return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);
}
}
static const struct frame_unwind sparc64_frame_unwind =
{
+ "sparc64 prologue",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
sparc64_frame_this_id,
static int
sparc64_16_byte_align_p (struct type *type)
{
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type->code () == TYPE_CODE_ARRAY)
{
struct type *t = check_typedef (TYPE_TARGET_TYPE (type));
if (sparc64_floating_p (t))
- return 1;
+ return 1;
}
if (sparc64_floating_p (type) && TYPE_LENGTH (type) == 16)
return 1;
{
int i;
- for (i = 0; i < TYPE_NFIELDS (type); i++)
+ for (i = 0; i < type->num_fields (); i++)
{
- struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
+ struct type *subtype = check_typedef (type->field (i).type ());
if (sparc64_16_byte_align_p (subtype))
return 1;
/* Store floating fields of element ELEMENT of an "parameter array"
that has type TYPE and is stored at BITPOS in VALBUF in the
- apropriate registers of REGCACHE. This function can be called
+ appropriate registers of REGCACHE. This function can be called
recursively and therefore handles floating types in addition to
structures. */
gdb_assert (element < 16);
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type->code () == TYPE_CODE_ARRAY)
{
gdb_byte buf[8];
int regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
valbuf += bitpos / 8;
if (len < 8)
- {
- memset (buf, 0, 8 - len);
- memcpy (buf + 8 - len, valbuf, len);
- valbuf = buf;
- len = 8;
- }
+ {
+ memset (buf, 0, 8 - len);
+ memcpy (buf + 8 - len, valbuf, len);
+ valbuf = buf;
+ len = 8;
+ }
for (int n = 0; n < (len + 3) / 4; n++)
- regcache->cooked_write (regnum + n, valbuf + n * 4);
+ regcache->cooked_write (regnum + n, valbuf + n * 4);
}
else if (sparc64_floating_p (type)
|| (sparc64_complex_floating_p (type) && len <= 16))
gdb_assert (bitpos == 0 || bitpos == 64);
regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
- + element + bitpos / 64;
+ + element + bitpos / 64;
regcache->cooked_write (regnum, valbuf + (bitpos / 8));
}
else
{
int i;
- for (i = 0; i < TYPE_NFIELDS (type); i++)
+ for (i = 0; i < type->num_fields (); i++)
{
- struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
- int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
+ struct type *subtype = check_typedef (type->field (i).type ());
+ int subpos = bitpos + type->field (i).loc_bitpos ();
sparc64_store_floating_fields (regcache, subtype, valbuf,
element, subpos);
}
/* GCC has an interesting bug. If TYPE is a structure that has
- a single `float' member, GCC doesn't treat it as a structure
- at all, but rather as an ordinary `float' argument. This
- argument will be stored in %f1, as required by the psABI.
- However, as a member of a structure the psABI requires it to
- be stored in %f0. This bug is present in GCC 3.3.2, but
- probably in older releases to. To appease GCC, if a
- structure has only a single `float' member, we store its
- value in %f1 too (we already have stored in %f0). */
- if (TYPE_NFIELDS (type) == 1)
+ a single `float' member, GCC doesn't treat it as a structure
+ at all, but rather as an ordinary `float' argument. This
+ argument will be stored in %f1, as required by the psABI.
+ However, as a member of a structure the psABI requires it to
+ be stored in %f0. This bug is present in GCC 3.3.2, but
+ probably in older releases to. To appease GCC, if a
+ structure has only a single `float' member, we store its
+ value in %f1 too (we already have stored in %f0). */
+ if (type->num_fields () == 1)
{
- struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, 0));
+ struct type *subtype = check_typedef (type->field (0).type ());
if (sparc64_floating_p (subtype) && TYPE_LENGTH (subtype) == 4)
regcache->cooked_write (SPARC_F1_REGNUM, valbuf);
{
struct gdbarch *gdbarch = regcache->arch ();
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type->code () == TYPE_CODE_ARRAY)
{
int len = TYPE_LENGTH (type);
int regnum = SPARC_F0_REGNUM + bitpos / 32;
valbuf += bitpos / 8;
if (len < 4)
- {
- gdb_byte buf[4];
- regcache->cooked_read (regnum, buf);
- memcpy (valbuf, buf + 4 - len, len);
- }
+ {
+ gdb_byte buf[4];
+ regcache->cooked_read (regnum, buf);
+ memcpy (valbuf, buf + 4 - len, len);
+ }
else
- for (int i = 0; i < (len + 3) / 4; i++)
- regcache->cooked_read (regnum + i, valbuf + i * 4);
+ for (int i = 0; i < (len + 3) / 4; i++)
+ regcache->cooked_read (regnum + i, valbuf + i * 4);
}
else if (sparc64_floating_p (type))
{
gdb_assert (bitpos == 0 || bitpos == 128);
regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
- + bitpos / 128;
+ + bitpos / 128;
regcache->cooked_read (regnum, valbuf + (bitpos / 8));
}
else if (len == 8)
{
int i;
- for (i = 0; i < TYPE_NFIELDS (type); i++)
+ for (i = 0; i < type->num_fields (); i++)
{
- struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
- int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
+ struct type *subtype = check_typedef (type->field (i).type ());
+ int subpos = bitpos + type->field (i).loc_bitpos ();
sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
}
static CORE_ADDR
sparc64_store_arguments (struct regcache *regcache, 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)
{
struct gdbarch *gdbarch = regcache->arch ();
/* Number of extended words in the "parameter array". */
/* First we calculate the number of extended words in the "parameter
array". While doing so we also convert some of the arguments. */
- if (struct_return)
+ if (return_method == return_method_struct)
num_elements++;
for (i = 0; i < nargs; i++)
sp -= len;
/* Use 16-byte alignment for these values. That's
- always correct, and wasting a few bytes shouldn't be
- a problem. */
+ always correct, and wasting a few bytes shouldn't be
+ a problem. */
sp &= ~0xf;
- write_memory (sp, value_contents (args[i]), len);
+ write_memory (sp, value_contents (args[i]).data (), len);
args[i] = value_from_pointer (lookup_pointer_type (type), sp);
num_elements++;
}
if (len == 16)
{
/* The psABI says that "Each quad-precision parameter
- value will be assigned to two extended words in the
- parameter array. */
+ value will be assigned to two extended words in the
+ parameter array. */
num_elements += 2;
/* The psABI says that "Long doubles must be
- quad-aligned, and thus a hole might be introduced
- into the parameter array to force alignment." Skip
- an element if necessary. */
+ quad-aligned, and thus a hole might be introduced
+ into the parameter array to force alignment." Skip
+ an element if necessary. */
if ((num_elements % 2) && sparc64_16_byte_align_p (type))
num_elements++;
}
/* The psABI says that "Every stack frame must be 16-byte aligned." */
sp &= ~0xf;
- /* Now we store the arguments in to the "paramater array". Some
+ /* Now we store the arguments in to the "parameter array". Some
Integer or Pointer arguments and Structure or Union arguments
will be passed in %o registers. Some Floating arguments and
floating members of structures are passed in floating-point
contents of any unused memory or registers in the "parameter
array" are undefined. */
- if (struct_return)
+ if (return_method == return_method_struct)
{
regcache_cooked_write_unsigned (regcache, SPARC_O0_REGNUM, struct_addr);
element++;
for (i = 0; i < nargs; i++)
{
- const gdb_byte *valbuf = value_contents (args[i]);
+ const gdb_byte *valbuf = value_contents (args[i]).data ();
struct type *type = value_type (args[i]);
int len = TYPE_LENGTH (type);
int regnum = -1;
element++;
if (element < 16)
regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
- + element / 2;
+ + element / 2;
}
else if (len == 8)
{
if (element < 16)
regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
- + element;
+ + element;
}
else if (len == 4)
{
/* The psABI says "Each single-precision parameter value
- will be assigned to one extended word in the
- parameter array, and right-justified within that
- word; the left half (even float register) is
- undefined." Even though the psABI says that "the
- left half is undefined", set it to zero here. */
+ will be assigned to one extended word in the
+ parameter array, and right-justified within that
+ word; the left half (even float register) is
+ undefined." Even though the psABI says that "the
+ left half is undefined", set it to zero here. */
memset (buf, 0, 4);
memcpy (buf + 4, valbuf, 4);
valbuf = buf;
len = 8;
if (element < 16)
regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
- + element;
+ + element;
}
}
else
regcache->cooked_write (regnum, valbuf);
/* If we're storing the value in a floating-point register,
- also store it in the corresponding %0 register(s). */
+ also store it in the corresponding %0 register(s). */
if (regnum >= gdbarch_num_regs (gdbarch))
- {
- regnum -= gdbarch_num_regs (gdbarch);
-
- if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)
- {
- gdb_assert (element < 6);
- regnum = SPARC_O0_REGNUM + element;
- regcache->cooked_write (regnum, valbuf);
- }
- else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)
- {
- gdb_assert (element < 5);
- regnum = SPARC_O0_REGNUM + element;
- regcache->cooked_write (regnum, valbuf);
- regcache->cooked_write (regnum + 1, valbuf + 8);
- }
- }
+ {
+ regnum -= gdbarch_num_regs (gdbarch);
+
+ if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)
+ {
+ gdb_assert (element < 6);
+ regnum = SPARC_O0_REGNUM + element;
+ regcache->cooked_write (regnum, valbuf);
+ }
+ else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)
+ {
+ gdb_assert (element < 5);
+ regnum = SPARC_O0_REGNUM + element;
+ regcache->cooked_write (regnum, valbuf);
+ regcache->cooked_write (regnum + 1, valbuf + 8);
+ }
+ }
}
/* Always store the argument in memory. */
sparc64_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)
{
/* Set return address. */
regcache_cooked_write_unsigned (regcache, SPARC_O7_REGNUM, bp_addr - 8);
/* Set up function arguments. */
- sp = sparc64_store_arguments (regcache, nargs, args, sp,
- struct_return, struct_addr);
+ sp = sparc64_store_arguments (regcache, nargs, args, sp, return_method,
+ struct_addr);
/* Allocate the register save area. */
sp -= 16 * 8;
for (i = 0; i < ((len + 7) / 8); i++)
regcache->cooked_read (SPARC_O0_REGNUM + i, buf + i * 8);
- if (TYPE_CODE (type) != TYPE_CODE_UNION)
+ if (type->code () != TYPE_CODE_UNION)
sparc64_extract_floating_fields (regcache, type, buf, 0);
memcpy (valbuf, buf, len);
}
regcache->cooked_read (SPARC_F0_REGNUM + i, buf + i * 4);
memcpy (valbuf, buf, len);
}
- else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ else if (type->code () == TYPE_CODE_ARRAY)
{
/* Small arrays are returned the same way as small structures. */
gdb_assert (len <= 32);
gdb_assert (sparc64_integral_or_pointer_p (type));
/* Just stripping off any unused bytes should preserve the
- signed-ness just fine. */
+ signed-ness just fine. */
regcache->cooked_read (SPARC_O0_REGNUM, buf);
memcpy (valbuf, buf + 8 - len, len);
}
gdb_assert (len <= 32);
/* Simplify matters by storing the complete value (including
- floating members) into %o0 and %o1. Floating members are
- also store in the appropriate floating-point registers. */
+ floating members) into %o0 and %o1. Floating members are
+ also store in the appropriate floating-point registers. */
memset (buf, 0, sizeof (buf));
memcpy (buf, valbuf, len);
for (i = 0; i < ((len + 7) / 8); i++)
regcache->cooked_write (SPARC_O0_REGNUM + i, buf + i * 8);
- if (TYPE_CODE (type) != TYPE_CODE_UNION)
+ if (type->code () != TYPE_CODE_UNION)
sparc64_store_floating_fields (regcache, type, buf, 0, 0);
}
else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
for (i = 0; i < len / 4; i++)
regcache->cooked_write (SPARC_F0_REGNUM + i, buf + i * 4);
}
- else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ else if (type->code () == TYPE_CODE_ARRAY)
{
/* Small arrays are returned the same way as small structures. */
gdb_assert (len <= 32);
void
sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
tdep->pc_regnum = SPARC64_PC_REGNUM;
tdep->npc_regnum = SPARC64_NPC_REGNUM;
if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
{
/* Not all of the register set variants include Locals and
- Inputs. For those that don't, we read them off the stack. */
+ Inputs. For those that don't, we read them off the stack. */
if (gregmap->r_l0_offset == -1)
{
ULONGEST sp;
if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
{
/* Not all of the register set variants include Locals and
- Inputs. For those that don't, we read them off the stack. */
+ Inputs. For those that don't, we read them off the stack. */
if (gregmap->r_l0_offset != -1)
{
int offset = gregmap->r_l0_offset;
projects / binutils-gdb.git / blobdiff