/* Target-dependent code for UltraSPARC.
- Copyright (C) 2003-2020 Free Software Foundation, Inc.
+ Copyright (C) 2003-2022 Free Software Foundation, Inc.
This file is part of GDB.
#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
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
read_maps_entry (const char *line,
- ULONGEST *addr, ULONGEST *endaddr)
+ ULONGEST *addr, ULONGEST *endaddr)
{
const char *p = line;
return proc->stat.is_avail;
proc->stat.checked_avail = true;
- if (target_auxv_search (current_top_target (), 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 (current_top_target (), 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;
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;
}
for (char *line = strtok_r (data.get (), "\n", &saveptr);
line;
line = strtok_r (NULL, "\n", &saveptr))
- {
- ULONGEST addr, endaddr;
+ {
+ 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;
}
{
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;
{
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;
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_printf (" ");
+ ++v_idx;
+ }
+ gdb_printf ("\n");
vaddr += maxelts;
}
}
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 ())
= 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 ())
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);
{
add_basic_prefix_cmd ("adi", class_support,
_("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);
+ &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 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,
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;
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);
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);
}
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++;
}
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. */
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++)
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