This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "inferior.h"
/* Total size of the register space. The raw registers are mapped
directly onto the raw register cache while the pseudo's are
either mapped onto raw-registers or memory. */
- descr->nr_cooked_registers = gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch);
- descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (current_gdbarch)
+ descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch);
+ descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (gdbarch)
+ gdbarch_num_pseudo_regs
- (current_gdbarch);
+ (gdbarch);
/* Fill in a table of register types. */
descr->register_type
/* Construct a strictly RAW register cache. Don't allow pseudo's
into the register cache. */
- descr->nr_raw_registers = gdbarch_num_regs (current_gdbarch);
+ descr->nr_raw_registers = gdbarch_num_regs (gdbarch);
/* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
array. This pretects GDB from erant code that accesses elements
struct regcache_descr *descr = regcache_descr (gdbarch);
int size;
gdb_assert (regnum >= 0
- && regnum < (gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch)));
+ && regnum < (gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch)));
size = descr->sizeof_register[regnum];
return size;
}
/* On the sparc, writing %g0 is a no-op, so we don't even want to
change the registers array if something writes to this register. */
- if (gdbarch_cannot_store_register (current_gdbarch, regnum))
+ if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
return;
/* If we have a valid copy of the register, and new value == old
if (gdbarch_read_pc_p (gdbarch))
pc_val = gdbarch_read_pc (gdbarch, regcache);
/* Else use per-frame method on get_current_frame. */
- else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
+ else if (gdbarch_pc_regnum (gdbarch) >= 0)
{
ULONGEST raw_val;
regcache_cooked_read_unsigned (regcache,
- gdbarch_pc_regnum (current_gdbarch),
+ gdbarch_pc_regnum (gdbarch),
&raw_val);
- pc_val = gdbarch_addr_bits_remove (current_gdbarch, raw_val);
+ pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
}
else
internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
if (gdbarch_write_pc_p (gdbarch))
gdbarch_write_pc (gdbarch, regcache, pc);
- if (gdbarch_pc_regnum (current_gdbarch) >= 0)
+ else if (gdbarch_pc_regnum (gdbarch) >= 0)
regcache_cooked_write_unsigned (regcache,
- gdbarch_pc_regnum (current_gdbarch), pc);
+ gdbarch_pc_regnum (gdbarch), pc);
else
internal_error (__FILE__, __LINE__,
_("write_pc_pid: Unable to update PC"));
fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
regcache->descr->sizeof_raw_register_valid_p);
fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
- gdbarch_num_regs (current_gdbarch));
+ gdbarch_num_regs (gdbarch));
fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
- gdbarch_num_pseudo_regs (current_gdbarch));
+ gdbarch_num_pseudo_regs (gdbarch));
#endif
gdb_assert (regcache->descr->nr_cooked_registers
- == (gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch)));
+ == (gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch)));
for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
{
fprintf_unfiltered (file, " %-10s", "Name");
else
{
- const char *p = gdbarch_register_name (current_gdbarch, regnum);
+ const char *p = gdbarch_register_name (gdbarch, regnum);
if (p == NULL)
p = "";
else if (p[0] == '\0')
/* Relative number. */
if (regnum < 0)
fprintf_unfiltered (file, " %4s", "Rel");
- else if (regnum < gdbarch_num_regs (current_gdbarch))
+ else if (regnum < gdbarch_num_regs (gdbarch))
fprintf_unfiltered (file, " %4d", regnum);
else
fprintf_unfiltered (file, " %4d",
- (regnum - gdbarch_num_regs (current_gdbarch)));
+ (regnum - gdbarch_num_regs (gdbarch)));
/* Offset. */
if (regnum < 0)
regcache_raw_read (regcache, regnum, buf);
fprintf_unfiltered (file, "0x");
dump_endian_bytes (file,
- gdbarch_byte_order (current_gdbarch), buf,
+ gdbarch_byte_order (gdbarch), buf,
regcache->descr->sizeof_register[regnum]);
}
}
regcache_cooked_read (regcache, regnum, buf);
fprintf_unfiltered (file, "0x");
dump_endian_bytes (file,
- gdbarch_byte_order (current_gdbarch), buf,
+ gdbarch_byte_order (gdbarch), buf,
regcache->descr->sizeof_register[regnum]);
}
}
regcache_print (char *args, enum regcache_dump_what what_to_dump)
{
if (args == NULL)
- regcache_dump (current_regcache, gdb_stdout, what_to_dump);
+ regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
else
{
struct ui_file *file = gdb_fopen (args, "w");
if (file == NULL)
perror_with_name (_("maintenance print architecture"));
- regcache_dump (current_regcache, file, what_to_dump);
+ regcache_dump (get_current_regcache (), file, what_to_dump);
ui_file_delete (file);
}
}