X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fsparc64-tdep.c;h=5ca5f2dca8c71c0b4e69781d02001b1864d71ced;hb=411c7e044fa99089d3030f2c61525c4d415f7b45;hp=6a1d9631bbe223799c78fd8053ce2ffe320370e0;hpb=87028b873938aa3cc756c99e33a328640dbc30bc;p=binutils-gdb.git diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c index 6a1d9631bbe..5ca5f2dca8c 100644 --- a/gdb/sparc64-tdep.c +++ b/gdb/sparc64-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for UltraSPARC. - Copyright (C) 2003-2017 Free Software Foundation, Inc. + Copyright (C) 2003-2022 Free Software Foundation, Inc. This file is part of GDB. @@ -19,7 +19,7 @@ #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" @@ -33,8 +33,8 @@ #include "target-descriptions.h" #include "target.h" #include "value.h" - #include "sparc64-tdep.h" +#include /* This file implements the SPARC 64-bit ABI as defined by the section "Low-Level System Information" of the SPARC Compliance @@ -86,7 +86,7 @@ static struct cmd_list_element *sparc64adilist = NULL; /* ADI stat settings. */ -typedef struct +struct adi_stat_t { /* The ADI block size. */ unsigned long blksize; @@ -108,11 +108,11 @@ typedef struct /* 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_) @@ -124,7 +124,7 @@ typedef struct sparc64_adi_info /* The ADI stat. */ adi_stat_t stat = {}; -} sparc64_adi_info; +}; static std::forward_list adi_proc_list; @@ -135,10 +135,10 @@ static sparc64_adi_info * 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 ()) { @@ -175,10 +175,10 @@ sparc64_forget_process (pid_t pid) { 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++; @@ -186,19 +186,11 @@ sparc64_forget_process (pid_t pid) } -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; @@ -214,7 +206,7 @@ read_maps_entry (const char *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; @@ -222,10 +214,12 @@ adi_available (void) return proc->stat.is_avail; proc->stat.checked_avail = true; - if (target_auxv_search (¤t_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 (¤t_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; @@ -238,7 +232,7 @@ adi_available (void) 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) { @@ -258,7 +252,7 @@ adi_normalize_address (CORE_ADDR addr) 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; } @@ -268,7 +262,7 @@ adi_align_address (CORE_ADDR naddr) 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; } @@ -285,7 +279,7 @@ adi_convert_byte_count (CORE_ADDR naddr, int nbytes, CORE_ADDR 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) @@ -295,7 +289,7 @@ adi_tag_fd (void) 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; } @@ -309,30 +303,32 @@ adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt) 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 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; } @@ -341,7 +337,7 @@ adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt) for "SIZE" number of bytes. */ static int -adi_read_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags) +adi_read_versions (CORE_ADDR vaddr, size_t size, gdb_byte *tags) { int fd = adi_tag_fd (); if (fd == -1) @@ -349,9 +345,9 @@ adi_read_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags) 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; @@ -370,9 +366,9 @@ adi_write_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags) 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; @@ -383,30 +379,29 @@ adi_write_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags) at "VADDR" with number of "CNT". */ static void -adi_print_versions (CORE_ADDR vaddr, size_t cnt, unsigned char *tags) +adi_print_versions (CORE_ADDR vaddr, size_t cnt, gdb_byte *tags) { 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; } } @@ -415,21 +410,17 @@ static void do_examine (CORE_ADDR start, int bcnt) { CORE_ADDR vaddr = adi_normalize_address (start); - struct cleanup *cleanup; CORE_ADDR vstart = adi_align_address (vaddr); int cnt = adi_convert_byte_count (vaddr, bcnt, vstart); - unsigned char *buf = (unsigned char *) xmalloc (cnt); - cleanup = make_cleanup (xfree, buf); - int read_cnt = adi_read_versions (vstart, cnt, buf); + gdb::def_vector buf (cnt); + int read_cnt = adi_read_versions (vstart, cnt, buf.data ()); if (read_cnt == -1) error (_("No ADI information")); else if (read_cnt < cnt) error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr)); - adi_print_versions (vstart, cnt, buf); - - do_cleanups (cleanup); + adi_print_versions (vstart, cnt, buf.data ()); } static void @@ -453,22 +444,20 @@ do_assign (CORE_ADDR start, size_t bcnt, int version) Command syntax: - adi (examine|x)/count */ + adi (examine|x)[/COUNT] [ADDR] */ static void -adi_examine_command (char *args, int from_tty) +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; - char *p = args; + const char *p = args; if (p && *p == '/') { p++; @@ -479,7 +468,7 @@ adi_examine_command (char *args, int from_tty) if (p != 0 && *p != 0) next_address = parse_and_eval_address (p); if (!cnt || !next_address) - error (_("Usage: adi examine|x[/count] ")); + error (_("Usage: adi examine|x[/COUNT] [ADDR]")); do_examine (next_address, cnt); } @@ -488,30 +477,33 @@ adi_examine_command (char *args, int from_tty) Command syntax: - adi (assign|a)/count = */ + adi (assign|a)[/COUNT] ADDR = VERSION */ static void -adi_assign_command (char *args, int from_tty) +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 ()) error (_("No ADI information")); - char *exp = args; + const char *exp = args; if (exp == 0) - error_no_arg (_("Usage: adi assign|a[/count] = ")); + error_no_arg (_(adi_usage)); char *q = (char *) strchr (exp, '='); if (q) *q++ = 0; else - error (_("Usage: adi assign|a[/count] = ")); + error ("%s", _(adi_usage)); size_t cnt = 1; - char *p = args; + const char *p = args; if (exp && *exp == '/') { p = exp + 1; @@ -522,32 +514,33 @@ adi_assign_command (char *args, int from_tty) if (p != 0 && *p != 0) next_address = parse_and_eval_address (p); else - error (_("Usage: adi assign|a[/count] = ")); + 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); } @@ -560,7 +553,7 @@ _initialize_sparc64_adi_tdep (void) 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: @@ -592,7 +585,7 @@ sparc64_integral_or_pointer_p (const struct type *type) static int sparc64_floating_p (const struct type *type) { - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_FLT: { @@ -612,7 +605,7 @@ sparc64_floating_p (const struct type *type) static int sparc64_complex_floating_p (const struct type *type) { - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_COMPLEX: { @@ -636,7 +629,7 @@ sparc64_complex_floating_p (const struct type *type) 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: @@ -655,7 +648,7 @@ sparc64_structure_or_union_p (const struct type *type) static struct type * sparc64_pstate_type (struct gdbarch *gdbarch) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + sparc_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (!tdep->sparc64_pstate_type) { @@ -682,7 +675,7 @@ sparc64_pstate_type (struct gdbarch *gdbarch) static struct type * sparc64_ccr_type (struct gdbarch *gdbarch) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + sparc_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (tdep->sparc64_ccr_type == NULL) { @@ -707,7 +700,7 @@ sparc64_ccr_type (struct gdbarch *gdbarch) static struct type * sparc64_fsr_type (struct gdbarch *gdbarch) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + sparc_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (!tdep->sparc64_fsr_type) { @@ -740,7 +733,7 @@ sparc64_fsr_type (struct gdbarch *gdbarch) static struct type * sparc64_fprs_type (struct gdbarch *gdbarch) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + sparc_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (!tdep->sparc64_fprs_type) { @@ -774,10 +767,14 @@ sparc64_fprs_type (struct gdbarch *gdbarch) "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, @@ -790,7 +787,7 @@ static const char *sparc64_register_names[] = /* 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", @@ -817,8 +814,8 @@ sparc64_pseudo_register_name (struct gdbarch *gdbarch, int regnum) 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. */ @@ -857,8 +854,8 @@ sparc64_pseudo_register_type (struct gdbarch *gdbarch, int 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 @@ -903,7 +900,7 @@ sparc64_register_type (struct gdbarch *gdbarch, int regnum) static enum register_status sparc64_pseudo_register_read (struct gdbarch *gdbarch, - struct regcache *regcache, + readable_regcache *regcache, int regnum, gdb_byte *buf) { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); @@ -914,27 +911,27 @@ sparc64_pseudo_register_read (struct gdbarch *gdbarch, if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM) { regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM); - status = regcache_raw_read (regcache, regnum, buf); + status = regcache->raw_read (regnum, buf); if (status == REG_VALID) - status = regcache_raw_read (regcache, regnum + 1, buf + 4); + status = regcache->raw_read (regnum + 1, buf + 4); return status; } else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM) { regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM); - return regcache_raw_read (regcache, regnum, buf); + return regcache->raw_read (regnum, buf); } else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM) { regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM); - status = regcache_raw_read (regcache, regnum, buf); + status = regcache->raw_read (regnum, buf); if (status == REG_VALID) - status = regcache_raw_read (regcache, regnum + 1, buf + 4); + status = regcache->raw_read (regnum + 1, buf + 4); if (status == REG_VALID) - status = regcache_raw_read (regcache, regnum + 2, buf + 8); + status = regcache->raw_read (regnum + 2, buf + 8); if (status == REG_VALID) - status = regcache_raw_read (regcache, regnum + 3, buf + 12); + status = regcache->raw_read (regnum + 3, buf + 12); return status; } @@ -942,9 +939,9 @@ sparc64_pseudo_register_read (struct gdbarch *gdbarch, { regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM); - status = regcache_raw_read (regcache, regnum, buf); + status = regcache->raw_read (regnum, buf); if (status == REG_VALID) - status = regcache_raw_read (regcache, regnum + 1, buf + 8); + status = regcache->raw_read (regnum + 1, buf + 8); return status; } @@ -955,7 +952,7 @@ sparc64_pseudo_register_read (struct gdbarch *gdbarch, { ULONGEST state; - status = regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state); + status = regcache->raw_read (SPARC64_STATE_REGNUM, &state); if (status != REG_VALID) return status; @@ -992,27 +989,27 @@ sparc64_pseudo_register_write (struct gdbarch *gdbarch, if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM) { regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM); - regcache_raw_write (regcache, regnum, buf); - regcache_raw_write (regcache, regnum + 1, buf + 4); + regcache->raw_write (regnum, buf); + regcache->raw_write (regnum + 1, buf + 4); } else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM) { regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM); - regcache_raw_write (regcache, regnum, buf); + regcache->raw_write (regnum, buf); } else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM) { regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM); - regcache_raw_write (regcache, regnum, buf); - regcache_raw_write (regcache, regnum + 1, buf + 4); - regcache_raw_write (regcache, regnum + 2, buf + 8); - regcache_raw_write (regcache, regnum + 3, buf + 12); + regcache->raw_write (regnum, buf); + regcache->raw_write (regnum + 1, buf + 4); + regcache->raw_write (regnum + 2, buf + 8); + regcache->raw_write (regnum + 3, buf + 12); } else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM) { regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM); - regcache_raw_write (regcache, regnum, buf); - regcache_raw_write (regcache, regnum + 1, buf + 8); + regcache->raw_write (regnum, buf); + regcache->raw_write (regnum + 1, buf + 8); } else if (regnum == SPARC64_CWP_REGNUM || regnum == SPARC64_PSTATE_REGNUM @@ -1114,12 +1111,12 @@ sparc64_frame_prev_register (struct frame_info *this_frame, void **this_cache, 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); } } @@ -1144,6 +1141,7 @@ sparc64_frame_prev_register (struct frame_info *this_frame, void **this_cache, static const struct frame_unwind sparc64_frame_unwind = { + "sparc64 prologue", NORMAL_FRAME, default_frame_unwind_stop_reason, sparc64_frame_this_id, @@ -1175,12 +1173,12 @@ static const struct frame_base sparc64_frame_base = 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; @@ -1189,9 +1187,9 @@ sparc64_16_byte_align_p (struct type *type) { 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; @@ -1203,7 +1201,7 @@ sparc64_16_byte_align_p (struct type *type) /* 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. */ @@ -1211,26 +1209,26 @@ static void sparc64_store_floating_fields (struct regcache *regcache, struct type *type, const gdb_byte *valbuf, int element, int bitpos) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); int len = TYPE_LENGTH (type); 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 (regcache, 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)) @@ -1243,15 +1241,15 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type, gdb_assert ((element % 2) == 0); regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2; - regcache_cooked_write (regcache, regnum, valbuf); + regcache->cooked_write (regnum, valbuf); } else if (len == 8) { gdb_assert (bitpos == 0 || bitpos == 64); regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM - + element + bitpos / 64; - regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8)); + + element + bitpos / 64; + regcache->cooked_write (regnum, valbuf + (bitpos / 8)); } else { @@ -1259,37 +1257,37 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type, gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 128); regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32; - regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8)); + regcache->cooked_write (regnum, valbuf + (bitpos / 8)); } } else if (sparc64_structure_or_union_p (type)) { 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 (regcache, SPARC_F1_REGNUM, valbuf); + regcache->cooked_write (SPARC_F1_REGNUM, valbuf); } } } @@ -1303,23 +1301,23 @@ static void sparc64_extract_floating_fields (struct regcache *regcache, struct type *type, gdb_byte *valbuf, int bitpos) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + 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 (regcache, 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 (regcache, 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)) { @@ -1331,15 +1329,15 @@ sparc64_extract_floating_fields (struct regcache *regcache, struct type *type, gdb_assert (bitpos == 0 || bitpos == 128); regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM - + bitpos / 128; - regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8)); + + bitpos / 128; + regcache->cooked_read (regnum, valbuf + (bitpos / 8)); } else if (len == 8) { gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256); regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + bitpos / 64; - regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8)); + regcache->cooked_read (regnum, valbuf + (bitpos / 8)); } else { @@ -1347,17 +1345,17 @@ sparc64_extract_floating_fields (struct regcache *regcache, struct type *type, gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 256); regnum = SPARC_F0_REGNUM + bitpos / 32; - regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8)); + regcache->cooked_read (regnum, valbuf + (bitpos / 8)); } } else if (sparc64_structure_or_union_p (type)) { 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); } @@ -1370,9 +1368,10 @@ sparc64_extract_floating_fields (struct regcache *regcache, struct type *type, 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 = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); /* Number of extended words in the "parameter array". */ int num_elements = 0; int element = 0; @@ -1384,7 +1383,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, /* 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++) @@ -1415,11 +1414,11 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, 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++; } @@ -1430,14 +1429,14 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, 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++; } @@ -1466,7 +1465,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, /* 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 @@ -1480,7 +1479,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, 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++; @@ -1488,7 +1487,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, 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; @@ -1510,7 +1509,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, { regnum = SPARC_O0_REGNUM + element; if (len > 8 && element < 5) - regcache_cooked_write (regcache, regnum + 1, valbuf + 8); + regcache->cooked_write (regnum + 1, valbuf + 8); } if (element < 16) @@ -1526,11 +1525,10 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, if (len == 16) { if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D30_REGNUM) - regcache_cooked_write (regcache, regnum + 1, valbuf + 8); + regcache->cooked_write (regnum + 1, valbuf + 8); if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D10_REGNUM) - regcache_cooked_write (regcache, - SPARC_O0_REGNUM + element + 1, - valbuf + 8); + regcache->cooked_write (SPARC_O0_REGNUM + element + 1, + valbuf + 8); } } } @@ -1543,29 +1541,29 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, 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 @@ -1578,28 +1576,28 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, if (regnum != -1) { - regcache_cooked_write (regcache, regnum, valbuf); + 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 (regcache, regnum, valbuf); - } - else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM) - { - gdb_assert (element < 5); - regnum = SPARC_O0_REGNUM + element; - regcache_cooked_write (regcache, regnum, valbuf); - regcache_cooked_write (regcache, 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. */ @@ -1625,14 +1623,15 @@ static CORE_ADDR 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; @@ -1664,8 +1663,8 @@ sparc64_extract_return_value (struct type *type, struct regcache *regcache, gdb_assert (len <= 32); for (i = 0; i < ((len + 7) / 8); i++) - regcache_cooked_read (regcache, SPARC_O0_REGNUM + i, buf + i * 8); - if (TYPE_CODE (type) != TYPE_CODE_UNION) + regcache->cooked_read (SPARC_O0_REGNUM + i, buf + i * 8); + if (type->code () != TYPE_CODE_UNION) sparc64_extract_floating_fields (regcache, type, buf, 0); memcpy (valbuf, buf, len); } @@ -1673,16 +1672,16 @@ sparc64_extract_return_value (struct type *type, struct regcache *regcache, { /* Floating return values. */ for (i = 0; i < len / 4; i++) - regcache_cooked_read (regcache, SPARC_F0_REGNUM + i, buf + i * 4); + 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); for (i = 0; i < ((len + 7) / 8); i++) - regcache_cooked_read (regcache, SPARC_O0_REGNUM + i, buf + i * 8); + regcache->cooked_read (SPARC_O0_REGNUM + i, buf + i * 8); memcpy (valbuf, buf, len); } else @@ -1691,8 +1690,8 @@ sparc64_extract_return_value (struct type *type, struct regcache *regcache, gdb_assert (sparc64_integral_or_pointer_p (type)); /* Just stripping off any unused bytes should preserve the - signed-ness just fine. */ - regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf); + signed-ness just fine. */ + regcache->cooked_read (SPARC_O0_REGNUM, buf); memcpy (valbuf, buf + 8 - len, len); } } @@ -1714,13 +1713,13 @@ sparc64_store_return_value (struct type *type, struct regcache *regcache, 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 (regcache, SPARC_O0_REGNUM + i, buf + i * 8); - if (TYPE_CODE (type) != TYPE_CODE_UNION) + regcache->cooked_write (SPARC_O0_REGNUM + i, buf + i * 8); + 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)) @@ -1728,9 +1727,9 @@ sparc64_store_return_value (struct type *type, struct regcache *regcache, /* Floating return values. */ memcpy (buf, valbuf, len); for (i = 0; i < len / 4; i++) - regcache_cooked_write (regcache, SPARC_F0_REGNUM + i, buf + i * 4); + 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); @@ -1738,7 +1737,7 @@ sparc64_store_return_value (struct type *type, struct regcache *regcache, memset (buf, 0, sizeof (buf)); memcpy (buf, valbuf, len); for (i = 0; i < ((len + 7) / 8); i++) - regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8); + regcache->cooked_write (SPARC_O0_REGNUM + i, buf + i * 8); } else { @@ -1748,7 +1747,7 @@ sparc64_store_return_value (struct type *type, struct regcache *regcache, /* ??? Do we need to do any sign-extension here? */ memset (buf, 0, 8); memcpy (buf + 8 - len, valbuf, len); - regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf); + regcache->cooked_write (SPARC_O0_REGNUM, buf); } } @@ -1807,7 +1806,7 @@ sparc64_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr) void sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + sparc_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); tdep->pc_regnum = SPARC64_PC_REGNUM; tdep->npc_regnum = SPARC64_NPC_REGNUM; @@ -1883,7 +1882,7 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap, struct regcache *regcache, int regnum, const void *gregs) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32); const gdb_byte *regs = (const gdb_byte *) gregs; @@ -1902,36 +1901,36 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap, psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12) | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS); store_unsigned_integer (buf, 4, byte_order, psr); - regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, buf); + regcache->raw_supply (SPARC32_PSR_REGNUM, buf); } if (regnum == SPARC32_PC_REGNUM || regnum == -1) - regcache_raw_supply (regcache, SPARC32_PC_REGNUM, - regs + gregmap->r_pc_offset + 4); + regcache->raw_supply (SPARC32_PC_REGNUM, + regs + gregmap->r_pc_offset + 4); if (regnum == SPARC32_NPC_REGNUM || regnum == -1) - regcache_raw_supply (regcache, SPARC32_NPC_REGNUM, - regs + gregmap->r_npc_offset + 4); + regcache->raw_supply (SPARC32_NPC_REGNUM, + regs + gregmap->r_npc_offset + 4); if (regnum == SPARC32_Y_REGNUM || regnum == -1) { int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size; - regcache_raw_supply (regcache, SPARC32_Y_REGNUM, regs + offset); + regcache->raw_supply (SPARC32_Y_REGNUM, regs + offset); } } else { if (regnum == SPARC64_STATE_REGNUM || regnum == -1) - regcache_raw_supply (regcache, SPARC64_STATE_REGNUM, - regs + gregmap->r_tstate_offset); + regcache->raw_supply (SPARC64_STATE_REGNUM, + regs + gregmap->r_tstate_offset); if (regnum == SPARC64_PC_REGNUM || regnum == -1) - regcache_raw_supply (regcache, SPARC64_PC_REGNUM, - regs + gregmap->r_pc_offset); + regcache->raw_supply (SPARC64_PC_REGNUM, + regs + gregmap->r_pc_offset); if (regnum == SPARC64_NPC_REGNUM || regnum == -1) - regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, - regs + gregmap->r_npc_offset); + regcache->raw_supply (SPARC64_NPC_REGNUM, + regs + gregmap->r_npc_offset); if (regnum == SPARC64_Y_REGNUM || regnum == -1) { @@ -1940,17 +1939,17 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap, memset (buf, 0, 8); memcpy (buf + 8 - gregmap->r_y_size, regs + gregmap->r_y_offset, gregmap->r_y_size); - regcache_raw_supply (regcache, SPARC64_Y_REGNUM, buf); + regcache->raw_supply (SPARC64_Y_REGNUM, buf); } if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1) && gregmap->r_fprs_offset != -1) - regcache_raw_supply (regcache, SPARC64_FPRS_REGNUM, - regs + gregmap->r_fprs_offset); + regcache->raw_supply (SPARC64_FPRS_REGNUM, + regs + gregmap->r_fprs_offset); } if (regnum == SPARC_G0_REGNUM || regnum == -1) - regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero); + regcache->raw_supply (SPARC_G0_REGNUM, &zero); if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1) { @@ -1962,7 +1961,7 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap, for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++) { if (regnum == i || regnum == -1) - regcache_raw_supply (regcache, i, regs + offset); + regcache->raw_supply (i, regs + offset); offset += 8; } } @@ -1970,7 +1969,7 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap, 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; @@ -1988,7 +1987,7 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap, for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++) { if (regnum == i || regnum == -1) - regcache_raw_supply (regcache, i, regs + offset); + regcache->raw_supply (i, regs + offset); offset += 8; } } @@ -2000,7 +1999,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap, const struct regcache *regcache, int regnum, void *gregs) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32); gdb_byte *regs = (gdb_byte *) gregs; @@ -2015,7 +2014,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap, gdb_byte buf[8]; tstate = extract_unsigned_integer (regs + offset, 8, byte_order); - regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, buf); + regcache->raw_collect (SPARC32_PSR_REGNUM, buf); psr = extract_unsigned_integer (buf, 4, byte_order); tstate |= (psr & PSR_ICC) << 12; if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS) @@ -2025,46 +2024,46 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap, } if (regnum == SPARC32_PC_REGNUM || regnum == -1) - regcache_raw_collect (regcache, SPARC32_PC_REGNUM, - regs + gregmap->r_pc_offset + 4); + regcache->raw_collect (SPARC32_PC_REGNUM, + regs + gregmap->r_pc_offset + 4); if (regnum == SPARC32_NPC_REGNUM || regnum == -1) - regcache_raw_collect (regcache, SPARC32_NPC_REGNUM, - regs + gregmap->r_npc_offset + 4); + regcache->raw_collect (SPARC32_NPC_REGNUM, + regs + gregmap->r_npc_offset + 4); if (regnum == SPARC32_Y_REGNUM || regnum == -1) { int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size; - regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + offset); + regcache->raw_collect (SPARC32_Y_REGNUM, regs + offset); } } else { if (regnum == SPARC64_STATE_REGNUM || regnum == -1) - regcache_raw_collect (regcache, SPARC64_STATE_REGNUM, - regs + gregmap->r_tstate_offset); + regcache->raw_collect (SPARC64_STATE_REGNUM, + regs + gregmap->r_tstate_offset); if (regnum == SPARC64_PC_REGNUM || regnum == -1) - regcache_raw_collect (regcache, SPARC64_PC_REGNUM, - regs + gregmap->r_pc_offset); + regcache->raw_collect (SPARC64_PC_REGNUM, + regs + gregmap->r_pc_offset); if (regnum == SPARC64_NPC_REGNUM || regnum == -1) - regcache_raw_collect (regcache, SPARC64_NPC_REGNUM, - regs + gregmap->r_npc_offset); + regcache->raw_collect (SPARC64_NPC_REGNUM, + regs + gregmap->r_npc_offset); if (regnum == SPARC64_Y_REGNUM || regnum == -1) { gdb_byte buf[8]; - regcache_raw_collect (regcache, SPARC64_Y_REGNUM, buf); + regcache->raw_collect (SPARC64_Y_REGNUM, buf); memcpy (regs + gregmap->r_y_offset, buf + 8 - gregmap->r_y_size, gregmap->r_y_size); } if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1) && gregmap->r_fprs_offset != -1) - regcache_raw_collect (regcache, SPARC64_FPRS_REGNUM, - regs + gregmap->r_fprs_offset); + regcache->raw_collect (SPARC64_FPRS_REGNUM, + regs + gregmap->r_fprs_offset); } @@ -2079,7 +2078,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap, for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++) { if (regnum == i || regnum == -1) - regcache_raw_collect (regcache, i, regs + offset); + regcache->raw_collect (i, regs + offset); offset += 8; } } @@ -2087,7 +2086,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap, 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; @@ -2098,7 +2097,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap, for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++) { if (regnum == i || regnum == -1) - regcache_raw_collect (regcache, i, regs + offset); + regcache->raw_collect (i, regs + offset); offset += 8; } } @@ -2110,21 +2109,21 @@ sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap, struct regcache *regcache, int regnum, const void *fpregs) { - int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32); + int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32); const gdb_byte *regs = (const gdb_byte *) fpregs; int i; for (i = 0; i < 32; i++) { if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1) - regcache_raw_supply (regcache, SPARC_F0_REGNUM + i, - regs + fpregmap->r_f0_offset + (i * 4)); + regcache->raw_supply (SPARC_F0_REGNUM + i, + regs + fpregmap->r_f0_offset + (i * 4)); } if (sparc32) { if (regnum == SPARC32_FSR_REGNUM || regnum == -1) - regcache_raw_supply (regcache, SPARC32_FSR_REGNUM, + regcache->raw_supply (SPARC32_FSR_REGNUM, regs + fpregmap->r_fsr_offset); } else @@ -2132,14 +2131,14 @@ sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap, for (i = 0; i < 16; i++) { if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1) - regcache_raw_supply (regcache, SPARC64_F32_REGNUM + i, - (regs + fpregmap->r_f0_offset - + (32 * 4) + (i * 8))); + regcache->raw_supply + (SPARC64_F32_REGNUM + i, + regs + fpregmap->r_f0_offset + (32 * 4) + (i * 8)); } if (regnum == SPARC64_FSR_REGNUM || regnum == -1) - regcache_raw_supply (regcache, SPARC64_FSR_REGNUM, - regs + fpregmap->r_fsr_offset); + regcache->raw_supply (SPARC64_FSR_REGNUM, + regs + fpregmap->r_fsr_offset); } } @@ -2148,36 +2147,36 @@ sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap, const struct regcache *regcache, int regnum, void *fpregs) { - int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32); + int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32); gdb_byte *regs = (gdb_byte *) fpregs; int i; for (i = 0; i < 32; i++) { if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1) - regcache_raw_collect (regcache, SPARC_F0_REGNUM + i, - regs + fpregmap->r_f0_offset + (i * 4)); + regcache->raw_collect (SPARC_F0_REGNUM + i, + regs + fpregmap->r_f0_offset + (i * 4)); } if (sparc32) { if (regnum == SPARC32_FSR_REGNUM || regnum == -1) - regcache_raw_collect (regcache, SPARC32_FSR_REGNUM, - regs + fpregmap->r_fsr_offset); + regcache->raw_collect (SPARC32_FSR_REGNUM, + regs + fpregmap->r_fsr_offset); } else { for (i = 0; i < 16; i++) { if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1) - regcache_raw_collect (regcache, SPARC64_F32_REGNUM + i, - (regs + fpregmap->r_f0_offset - + (32 * 4) + (i * 8))); + regcache->raw_collect (SPARC64_F32_REGNUM + i, + (regs + fpregmap->r_f0_offset + + (32 * 4) + (i * 8))); } if (regnum == SPARC64_FSR_REGNUM || regnum == -1) - regcache_raw_collect (regcache, SPARC64_FSR_REGNUM, - regs + fpregmap->r_fsr_offset); + regcache->raw_collect (SPARC64_FSR_REGNUM, + regs + fpregmap->r_fsr_offset); } }