From 50fd1280820c4c5a3403a68d53a76dc225dd8702 Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Wed, 25 May 2005 03:12:13 +0000 Subject: [PATCH] 2005-05-24 Andrew Cagney * rs6000-tdep.c (ppc_supply_reg, ppc_collect_reg): Use gdb_byte for byte buffers. (rs6000_fetch_pointer_argument): Use get_frame_register_unsigned. (rs6000_software_single_step, sstep_breaks, skip_prologue) (rs6000_push_dummy_call, rs6000_push_dummy_call) (rs6000_push_dummy_call, rs6000_push_dummy_call) (rs6000_register_to_value, e500_pseudo_register_read) (rs6000_store_return_value, e500_pseudo_register_write) (rs6000_frame_prev_register, rs6000_extract_return_value): Ditto. * ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call) (ppc_sysv_abi_push_dummy_call, do_ppc_sysv_return_value) (do_ppc_sysv_return_value, ppc_sysv_abi_return_value) (ppc_sysv_abi_broken_return_value) (ppc64_sysv_abi_push_dummy_call, ppc64_sysv_abi_push_dummy_call) (ppc64_sysv_abi_push_dummy_call, ppc64_sysv_abi_return_value) (ppc64_sysv_abi_return_value, ppc64_sysv_abi_return_value): Ditto. * ppc-linux-tdep.c (ppc_linux_in_sigtramp) (ppc_linux_at_sigtramp_return_path) (ppc_linux_skip_trampoline_code) (ppc_linux_memory_remove_breakpoint, ppc_linux_return_value): * rs6000-tdep.c (rs6000_value_to_register) (rs6000_register_to_value): Ditto. * ppc-tdep.h (ppc_sysv_abi_return_value) (ppc64_sysv_abi_return_value, ppc_sysv_abi_broken_return_value) (ppc_linux_memory_remove_breakpoint): Ditto. --- gdb/ChangeLog | 28 ++++++++++++++++++++++ gdb/ppc-linux-tdep.c | 18 +++++++------- gdb/ppc-sysv-tdep.c | 32 ++++++++++++------------- gdb/ppc-tdep.h | 15 ++++++------ gdb/rs6000-tdep.c | 68 +++++++++++++++++++++++++--------------------------- 5 files changed, 94 insertions(+), 67 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index ffd1c80..a91f556 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,31 @@ +2005-05-24 Andrew Cagney + + * rs6000-tdep.c (ppc_supply_reg, ppc_collect_reg): Use gdb_byte + for byte buffers. + (rs6000_fetch_pointer_argument): Use get_frame_register_unsigned. + (rs6000_software_single_step, sstep_breaks, skip_prologue) + (rs6000_push_dummy_call, rs6000_push_dummy_call) + (rs6000_push_dummy_call, rs6000_push_dummy_call) + (rs6000_register_to_value, e500_pseudo_register_read) + (rs6000_store_return_value, e500_pseudo_register_write) + (rs6000_frame_prev_register, rs6000_extract_return_value): Ditto. + * ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call) + (ppc_sysv_abi_push_dummy_call, do_ppc_sysv_return_value) + (do_ppc_sysv_return_value, ppc_sysv_abi_return_value) + (ppc_sysv_abi_broken_return_value) + (ppc64_sysv_abi_push_dummy_call, ppc64_sysv_abi_push_dummy_call) + (ppc64_sysv_abi_push_dummy_call, ppc64_sysv_abi_return_value) + (ppc64_sysv_abi_return_value, ppc64_sysv_abi_return_value): Ditto. + * ppc-linux-tdep.c (ppc_linux_in_sigtramp) + (ppc_linux_at_sigtramp_return_path) + (ppc_linux_skip_trampoline_code) + (ppc_linux_memory_remove_breakpoint, ppc_linux_return_value): + * rs6000-tdep.c (rs6000_value_to_register) + (rs6000_register_to_value): Ditto. + * ppc-tdep.h (ppc_sysv_abi_return_value) + (ppc64_sysv_abi_return_value, ppc_sysv_abi_broken_return_value) + (ppc_linux_memory_remove_breakpoint): Ditto. + 2005-05-24 Ulrich Weigand * s390-tdep.c (s390_frame_prev_register): Change type of last diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c index 6b69573..e6d8941 100644 --- a/gdb/ppc-linux-tdep.c +++ b/gdb/ppc-linux-tdep.c @@ -157,7 +157,7 @@ ppc_linux_in_sigtramp (CORE_ADDR pc, char *func_name) CORE_ADDR lr; CORE_ADDR sp; CORE_ADDR tramp_sp; - char buf[4]; + gdb_byte buf[4]; CORE_ADDR handler; lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum); @@ -205,7 +205,7 @@ insn_is_sigreturn (unsigned long pcinsn) static int ppc_linux_at_sigtramp_return_path (CORE_ADDR pc) { - char buf[12]; + gdb_byte buf[12]; unsigned long pcinsn; if (target_read_memory (pc - 4, buf, sizeof (buf)) != 0) return 0; @@ -224,7 +224,7 @@ ppc_linux_at_sigtramp_return_path (CORE_ADDR pc) static CORE_ADDR ppc_linux_skip_trampoline_code (CORE_ADDR pc) { - char buf[4]; + gdb_byte buf[4]; struct obj_section *sect; struct objfile *objfile; unsigned long insn; @@ -317,7 +317,8 @@ ppc_linux_skip_trampoline_code (CORE_ADDR pc) /* Fetch the string; we don't know how long it is. Is it possible that the following will fail because we're trying to fetch too much? */ - if (target_read_memory (strtab + symidx, symname, sizeof (symname)) != 0) + if (target_read_memory (strtab + symidx, (gdb_byte *) symname, + sizeof (symname)) != 0) return 0; /* This might not work right if we have multiple symbols with the @@ -455,12 +456,13 @@ ppc_linux_skip_trampoline_code (CORE_ADDR pc) regard to removing breakpoints in some potentially self modifying code. */ int -ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache) +ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, + gdb_byte *contents_cache) { const unsigned char *bp; int val; int bplen; - char old_contents[BREAKPOINT_MAX]; + gdb_byte old_contents[BREAKPOINT_MAX]; /* Determine appropriate breakpoint contents and size for this address. */ bp = BREAKPOINT_FROM_PC (&addr, &bplen); @@ -485,8 +487,8 @@ ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache) static enum return_value_convention ppc_linux_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, void *readbuf, - const void *writebuf) + struct regcache *regcache, gdb_byte *readbuf, + const gdb_byte *writebuf) { if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT || TYPE_CODE (valtype) == TYPE_CODE_UNION) diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c index 7863aca..b172dc0 100644 --- a/gdb/ppc-sysv-tdep.c +++ b/gdb/ppc-sysv-tdep.c @@ -114,7 +114,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { /* Always store the floating point value using the register's floating-point format. */ - char regval[MAX_REGISTER_SIZE]; + gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum + freg); convert_typed_floating (val, type, regval, regtype); @@ -242,7 +242,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { /* Reduce the parameter down to something that fits in a "word". */ - char word[MAX_REGISTER_SIZE]; + gdb_byte word[MAX_REGISTER_SIZE]; memset (word, 0, MAX_REGISTER_SIZE); if (len > tdep->wordsize || TYPE_CODE (type) == TYPE_CODE_STRUCT @@ -340,7 +340,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, { /* Floats and doubles stored in "f1". Convert the value to the required type. */ - char regval[MAX_REGISTER_SIZE]; + gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum + 1); regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval); @@ -350,7 +350,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, { /* Floats and doubles stored in "f1". Convert the value to the register's "double" type. */ - char regval[MAX_REGISTER_SIZE]; + gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum); convert_typed_floating (writebuf, type, regval, regtype); regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval); @@ -488,7 +488,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, /* This matches SVr4 PPC, it does not match GCC. */ /* The value is right-padded to 8 bytes and then loaded, as two "words", into r3/r4. */ - char regvals[MAX_REGISTER_SIZE * 2]; + gdb_byte regvals[MAX_REGISTER_SIZE * 2]; regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regvals + 0 * tdep->wordsize); if (TYPE_LENGTH (type) > tdep->wordsize) @@ -501,7 +501,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, /* This matches SVr4 PPC, it does not match GCC. */ /* The value is padded out to 8 bytes and then loaded, as two "words" into r3/r4. */ - char regvals[MAX_REGISTER_SIZE * 2]; + gdb_byte regvals[MAX_REGISTER_SIZE * 2]; memset (regvals, 0, sizeof regvals); memcpy (regvals, writebuf, TYPE_LENGTH (type)); regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, @@ -517,8 +517,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, enum return_value_convention ppc_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, void *readbuf, - const void *writebuf) + struct regcache *regcache, gdb_byte *readbuf, + const gdb_byte *writebuf) { return do_ppc_sysv_return_value (gdbarch, valtype, regcache, readbuf, writebuf, 0); @@ -528,7 +528,7 @@ enum return_value_convention ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, - void *readbuf, const void *writebuf) + gdb_byte *readbuf, const gdb_byte *writebuf) { return do_ppc_sysv_return_value (gdbarch, valtype, regcache, readbuf, writebuf, 1); @@ -688,7 +688,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (ppc_floating_point_unit_p (current_gdbarch) && freg <= 13) { - char regval[MAX_REGISTER_SIZE]; + gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum); convert_typed_floating (val, type, regval, regtype); @@ -707,7 +707,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, This code interprets that to mean: store it, left aligned, in the general register. */ - char regval[MAX_REGISTER_SIZE]; + gdb_byte regval[MAX_REGISTER_SIZE]; memset (regval, 0, sizeof regval); memcpy (regval, val, TYPE_LENGTH (type)); regcache_cooked_write (regcache, @@ -782,7 +782,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { if (write_pass && greg <= 10) { - char regval[MAX_REGISTER_SIZE]; + gdb_byte regval[MAX_REGISTER_SIZE]; int len = TYPE_LENGTH (type) - byte; if (len > tdep->wordsize) len = tdep->wordsize; @@ -880,8 +880,8 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, corresponding register return-value location. */ enum return_value_convention ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, void *readbuf, - const void *writebuf) + struct regcache *regcache, gdb_byte *readbuf, + const gdb_byte *writebuf) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); @@ -893,7 +893,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, /* Floats and doubles in F1. */ if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8) { - char regval[MAX_REGISTER_SIZE]; + gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum); if (writebuf != NULL) { @@ -984,7 +984,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, int i; for (i = 0; i < 2; i++) { - char regval[MAX_REGISTER_SIZE]; + gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (current_gdbarch, tdep->ppc_fp0_regnum); if (writebuf != NULL) diff --git a/gdb/ppc-tdep.h b/gdb/ppc-tdep.h index 1a5bc6f..a2c77da 100644 --- a/gdb/ppc-tdep.h +++ b/gdb/ppc-tdep.h @@ -33,13 +33,13 @@ struct type; enum return_value_convention ppc_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, - void *readbuf, - const void *writebuf); + gdb_byte *readbuf, + const gdb_byte *writebuf); enum return_value_convention ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, - void *readbuf, - const void *writebuf); + gdb_byte *readbuf, + const gdb_byte *writebuf); CORE_ADDR ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, @@ -56,7 +56,8 @@ CORE_ADDR ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR struct_addr); CORE_ADDR ppc64_sysv_abi_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr); -int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache); +int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, + gdb_byte *contents_cache); struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void); void ppc_linux_supply_gregset (struct regcache *regcache, int regnum, const void *gregs, size_t size, @@ -68,8 +69,8 @@ void ppc_linux_supply_fpregset (const struct regset *regset, enum return_value_convention ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, - void *readbuf, - const void *writebuf); + gdb_byte *readbuf, + const gdb_byte *writebuf); /* From rs6000-tdep.c... */ int altivec_register_p (int regno); diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c index 230f110..7f37d3e 100644 --- a/gdb/rs6000-tdep.c +++ b/gdb/rs6000-tdep.c @@ -112,12 +112,12 @@ struct reg /* Breakpoint shadows for the single step instructions will be kept here. */ static struct sstep_breaks - { - /* Address, or 0 if this is not in use. */ - CORE_ADDR address; - /* Shadow contents. */ - char data[4]; - } +{ + /* Address, or 0 if this is not in use. */ + CORE_ADDR address; + /* Shadow contents. */ + gdb_byte data[4]; +} stepBreaks[2]; /* Hook for determining the TOC address when calling functions in the @@ -319,7 +319,7 @@ rs6000_register_sim_regno (int reg) static void ppc_supply_reg (struct regcache *regcache, int regnum, - const char *regs, size_t offset) + const gdb_byte *regs, size_t offset) { if (regnum != -1 && offset != -1) regcache_raw_supply (regcache, regnum, regs + offset); @@ -327,7 +327,7 @@ ppc_supply_reg (struct regcache *regcache, int regnum, static void ppc_collect_reg (const struct regcache *regcache, int regnum, - char *regs, size_t offset) + gdb_byte *regs, size_t offset) { if (regnum != -1 && offset != -1) regcache_raw_collect (regcache, regnum, regs + offset); @@ -520,9 +520,7 @@ static CORE_ADDR rs6000_fetch_pointer_argument (struct frame_info *frame, int argi, struct type *type) { - CORE_ADDR addr; - get_frame_register (frame, 3 + argi, &addr); - return addr; + return get_frame_register_unsigned (frame, 3 + argi); } /* Calculate the destination of a branch/jump. Return -1 if not a branch. */ @@ -621,7 +619,7 @@ rs6000_software_single_step (enum target_signal signal, { CORE_ADDR dummy; int breakp_sz; - const char *breakp = rs6000_breakpoint_from_pc (&dummy, &breakp_sz); + const gdb_byte *breakp = rs6000_breakpoint_from_pc (&dummy, &breakp_sz); int ii, insn; CORE_ADDR loc; CORE_ADDR breaks[2]; @@ -831,7 +829,7 @@ skip_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct rs6000_framedata *fdata) CORE_ADDR orig_pc = pc; CORE_ADDR last_prologue_pc = pc; CORE_ADDR li_found_pc = 0; - char buf[4]; + gdb_byte buf[4]; unsigned long op; long offset = 0; long vr_saved_offset = 0; @@ -1429,7 +1427,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function, int len = 0; int argno; /* current argument number */ int argbytes; /* current argument byte */ - char tmp_buffer[50]; + gdb_byte tmp_buffer[50]; int f_argno = 0; /* current floating point argno */ int wordsize = gdbarch_tdep (current_gdbarch)->wordsize; CORE_ADDR func_addr = find_function_addr (function, NULL); @@ -1507,7 +1505,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Argument takes more than one register. */ while (argbytes < len) { - char word[MAX_REGISTER_SIZE]; + gdb_byte word[MAX_REGISTER_SIZE]; memset (word, 0, reg_size); memcpy (word, ((char *) value_contents (arg)) + argbytes, @@ -1528,7 +1526,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { /* Argument can fit in one register. No problem. */ int adj = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? reg_size - len : 0; - char word[MAX_REGISTER_SIZE]; + gdb_byte word[MAX_REGISTER_SIZE]; memset (word, 0, reg_size); memcpy (word, value_contents (arg), len); @@ -1589,7 +1587,7 @@ ran_out_of_registers_for_arguments: if (argbytes) { write_memory (sp + 24 + (ii * 4), - ((char *) value_contents (arg)) + argbytes, + value_contents (arg) + argbytes, len - argbytes); ++argno; ii += ((len - argbytes + 3) & -4) / 4; @@ -1617,9 +1615,7 @@ ran_out_of_registers_for_arguments: ++f_argno; } - write_memory (sp + 24 + (ii * 4), - (char *) value_contents (arg), - len); + write_memory (sp + 24 + (ii * 4), value_contents (arg), len); ii += ((len + 3) & -4) / 4; } } @@ -1665,8 +1661,8 @@ rs6000_use_struct_convention (int gcc_p, struct type *value_type) } static void -rs6000_extract_return_value (struct type *valtype, bfd_byte *regbuf, - bfd_byte *valbuf) +rs6000_extract_return_value (struct type *valtype, gdb_byte *regbuf, + gdb_byte *valbuf) { int offset = 0; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); @@ -1933,10 +1929,10 @@ static void rs6000_register_to_value (struct frame_info *frame, int regnum, struct type *type, - void *to) + gdb_byte *to) { const struct reg *reg = gdbarch_tdep (current_gdbarch)->regs + regnum; - char from[MAX_REGISTER_SIZE]; + gdb_byte from[MAX_REGISTER_SIZE]; gdb_assert (reg->fpr); gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT); @@ -1949,10 +1945,10 @@ static void rs6000_value_to_register (struct frame_info *frame, int regnum, struct type *type, - const void *from) + const gdb_byte *from) { const struct reg *reg = gdbarch_tdep (current_gdbarch)->regs + regnum; - char to[MAX_REGISTER_SIZE]; + gdb_byte to[MAX_REGISTER_SIZE]; gdb_assert (reg->fpr); gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT); @@ -1986,14 +1982,14 @@ rs6000_value_to_register (struct frame_info *frame, co-variant type qualifiers, ... */ static void e500_move_ev_register (void (*move) (struct regcache *regcache, - int regnum, void *buf), + int regnum, gdb_byte *buf), struct regcache *regcache, int ev_reg, - void *buffer) + gdb_byte *buffer) { struct gdbarch *arch = get_regcache_arch (regcache); struct gdbarch_tdep *tdep = gdbarch_tdep (arch); int reg_index; - char *byte_buffer = buffer; + gdb_byte *byte_buffer = buffer; gdb_assert (tdep->ppc_ev0_regnum <= ev_reg && ev_reg < tdep->ppc_ev0_regnum + ppc_num_gprs); @@ -2014,7 +2010,7 @@ e500_move_ev_register (void (*move) (struct regcache *regcache, static void e500_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, - int reg_nr, void *buffer) + int reg_nr, gdb_byte *buffer) { struct gdbarch *regcache_arch = get_regcache_arch (regcache); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); @@ -2033,7 +2029,7 @@ e500_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, static void e500_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, - int reg_nr, const void *buffer) + int reg_nr, const gdb_byte *buffer) { struct gdbarch *regcache_arch = get_regcache_arch (regcache); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); @@ -2042,9 +2038,9 @@ e500_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, if (tdep->ppc_ev0_regnum <= reg_nr && reg_nr < tdep->ppc_ev0_regnum + ppc_num_gprs) - e500_move_ev_register ((void (*) (struct regcache *, int, void *)) + e500_move_ev_register ((void (*) (struct regcache *, int, gdb_byte *)) regcache_raw_write, - regcache, reg_nr, (void *) buffer); + regcache, reg_nr, (gdb_byte *) buffer); else internal_error (__FILE__, __LINE__, _("e500_pseudo_register_read: " @@ -2161,7 +2157,7 @@ rs6000_dwarf2_reg_to_regnum (int num) static void rs6000_store_return_value (struct type *type, struct regcache *regcache, - const void *valbuf) + const gdb_byte *valbuf) { struct gdbarch *gdbarch = get_regcache_arch (regcache); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); @@ -2201,7 +2197,7 @@ rs6000_store_return_value (struct type *type, register_size (gdbarch, regnum)); regcache_cooked_write_part (regcache, regnum, 0, bytes_to_write, - (char *) valbuf + bytes_written); + valbuf + bytes_written); regnum++; bytes_written += bytes_to_write; } @@ -3001,7 +2997,7 @@ rs6000_frame_prev_register (struct frame_info *next_frame, void **this_cache, int regnum, int *optimizedp, enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnump, void *valuep) + int *realnump, gdb_byte *valuep) { struct rs6000_frame_cache *info = rs6000_frame_cache (next_frame, this_cache); -- 2.7.4