From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 749 invoked by alias); 22 Jul 2002 22:52:02 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 742 invoked from network); 22 Jul 2002 22:52:01 -0000 Received: from unknown (HELO localhost.redhat.com) (216.138.202.10) by sources.redhat.com with SMTP; 22 Jul 2002 22:52:01 -0000 Received: from ges.redhat.com (localhost [127.0.0.1]) by localhost.redhat.com (Postfix) with ESMTP id 93B863CEB for ; Mon, 22 Jul 2002 18:52:01 -0400 (EDT) Message-ID: <3D3C8C91.3000102@ges.redhat.com> Date: Mon, 22 Jul 2002 16:19:00 -0000 From: Andrew Cagney User-Agent: Mozilla/5.0 (X11; U; NetBSD macppc; en-US; rv:1.0.0) Gecko/20020708 X-Accept-Language: en-us, en MIME-Version: 1.0 To: gdb-patches@sources.redhat.com Subject: [patch/comit] regcache read/write -> regcache raw read/write Content-Type: multipart/mixed; boundary="------------070803080106030407060708" X-SW-Source: 2002-07/txt/msg00448.txt.bz2 This is a multi-part message in MIME format. --------------070803080106030407060708 Content-Type: text/plain; charset=us-ascii; format=flowed Content-Transfer-Encoding: 7bit Content-length: 302 Hello, This patch starts to bring the regcache naming schema into line with its proposed documentation (previous post). Following on from this will be: - corresponding cooked functions - change to gdbarch to pass the register cache to that function I'll commit it tomorrow. Andrew --------------070803080106030407060708 Content-Type: text/plain; name="diffs" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="diffs" Content-length: 20309 2002-07-22 Andrew Cagney * regcache.h (regcache_raw_read, regcache_raw_write): Replace regcache_read and regcache_write. (regcache_raw_read_as_address): Replace regcache_read_as_address. * regcache.c: Update. * sh-tdep.c (sh64_push_arguments): Update comment. (sh_pseudo_register_read): Update. (sh_pseudo_register_write): Update. (sh4_register_read): Update. (sh4_register_write): Update. (sh64_pseudo_register_read): Update. (sh64_pseudo_register_write): Update. (sh64_register_read): Update. (sh64_register_write): Update. * i386-tdep.c (i386_extract_return_value): Update. (i386_extract_struct_value_address): Update. (i386_extract_return_value): * blockframe.c (generic_read_register_dummy): Update. (generic_call_dummy_register_unwind): Update * infrun.c (write_inferior_status_register): Update. Index: blockframe.c =================================================================== RCS file: /cvs/src/src/gdb/blockframe.c,v retrieving revision 1.33 diff -u -r1.33 blockframe.c --- blockframe.c 16 Jul 2002 07:42:25 -0000 1.33 +++ blockframe.c 22 Jul 2002 22:26:51 -0000 @@ -1215,7 +1215,7 @@ struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp); if (dummy_regs) - return regcache_read_as_address (dummy_regs, regno); + return regcache_raw_read_as_address (dummy_regs, regno); else return 0; } @@ -1393,7 +1393,7 @@ gdbarch_register_read() method so that it, on the fly, constructs either a raw or pseudo register from the raw register cache. */ - regcache_read (registers, regnum, bufferp); + regcache_raw_read (registers, regnum, bufferp); } } @@ -1543,8 +1543,9 @@ gdbarch_register_read() method so that it, on the fly, constructs either a raw or pseudo register from the raw register cache. */ - regcache_read (generic_find_dummy_frame (frame->pc, frame->frame), - regnum, raw_buffer); + regcache_raw_read (generic_find_dummy_frame (frame->pc, + frame->frame), + regnum, raw_buffer); return; } Index: i386-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/i386-tdep.c,v retrieving revision 1.72 diff -u -r1.72 i386-tdep.c --- i386-tdep.c 4 Jul 2002 08:18:20 -0000 1.72 +++ i386-tdep.c 22 Jul 2002 22:26:52 -0000 @@ -962,7 +962,7 @@ its contents to the desired type. This is probably not exactly how it would happen on the target itself, but it is the best we can do. */ - regcache_read (regcache, FP0_REGNUM, buf); + regcache_raw_read (regcache, FP0_REGNUM, buf); convert_typed_floating (buf, builtin_type_i387_ext, valbuf, type); } else @@ -972,14 +972,14 @@ if (len <= low_size) { - regcache_read (regcache, LOW_RETURN_REGNUM, buf); + regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf); memcpy (valbuf, buf, len); } else if (len <= (low_size + high_size)) { - regcache_read (regcache, LOW_RETURN_REGNUM, buf); + regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf); memcpy (valbuf, buf, low_size); - regcache_read (regcache, HIGH_RETURN_REGNUM, buf); + regcache_raw_read (regcache, HIGH_RETURN_REGNUM, buf); memcpy (valbuf + low_size, buf, len - low_size); } else @@ -1066,7 +1066,7 @@ static CORE_ADDR i386_extract_struct_value_address (struct regcache *regcache) { - return regcache_read_as_address (regcache, LOW_RETURN_REGNUM); + return regcache_raw_read_as_address (regcache, LOW_RETURN_REGNUM); } Index: infrun.c =================================================================== RCS file: /cvs/src/src/gdb/infrun.c,v retrieving revision 1.63 diff -u -r1.63 infrun.c --- infrun.c 18 Jul 2002 17:53:49 -0000 1.63 +++ infrun.c 22 Jul 2002 22:26:54 -0000 @@ -3917,7 +3917,7 @@ int size = REGISTER_RAW_SIZE (regno); void *buf = alloca (size); store_signed_integer (buf, size, val); - regcache_write (inf_status->registers, regno, buf); + regcache_raw_write (inf_status->registers, regno, buf); } /* Save all of the information associated with the inferior<==>gdb Index: regcache.c =================================================================== RCS file: /cvs/src/src/gdb/regcache.c,v retrieving revision 1.40 diff -u -r1.40 regcache.c --- regcache.c 3 Jul 2002 20:36:54 -0000 1.40 +++ regcache.c 22 Jul 2002 22:26:54 -0000 @@ -312,8 +312,8 @@ for (i = 0; i < src->descr->nr_raw_registers; i++) { /* Should we worry about the valid bit here? */ - regcache_read (src, i, buf); - regcache_write (dst, i, buf); + regcache_raw_read (src, i, buf); + regcache_raw_write (dst, i, buf); } } @@ -362,13 +362,13 @@ } CORE_ADDR -regcache_read_as_address (struct regcache *regcache, int regnum) +regcache_raw_read_as_address (struct regcache *regcache, int regnum) { char *buf; gdb_assert (regcache != NULL); gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); buf = alloca (regcache->descr->sizeof_register[regnum]); - regcache_read (regcache, regnum, buf); + regcache_raw_read (regcache, regnum, buf); return extract_address (buf, regcache->descr->sizeof_register[regnum]); } @@ -671,7 +671,7 @@ } void -regcache_read (struct regcache *regcache, int regnum, char *buf) +regcache_raw_read (struct regcache *regcache, int regnum, char *buf) { gdb_assert (regcache != NULL && buf != NULL); gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); @@ -761,7 +761,7 @@ } void -regcache_write (struct regcache *regcache, int regnum, char *buf) +regcache_raw_write (struct regcache *regcache, int regnum, char *buf) { gdb_assert (regcache != NULL && buf != NULL); gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); Index: regcache.h =================================================================== RCS file: /cvs/src/src/gdb/regcache.h,v retrieving revision 1.9 diff -u -r1.9 regcache.h --- regcache.h 3 Jul 2002 20:36:54 -0000 1.9 +++ regcache.h 22 Jul 2002 22:26:54 -0000 @@ -35,10 +35,10 @@ /* Transfer a raw register [0..NUM_REGS) between core-gdb and the regcache. */ -void regcache_read (struct regcache *regcache, int rawnum, char *buf); -void regcache_write (struct regcache *regcache, int rawnum, char *buf); +void regcache_raw_read (struct regcache *regcache, int rawnum, char *buf); +void regcache_raw_write (struct regcache *regcache, int rawnum, char *buf); int regcache_valid_p (struct regcache *regcache, int regnum); -CORE_ADDR regcache_read_as_address (struct regcache *regcache, int rawnum); +CORE_ADDR regcache_raw_read_as_address (struct regcache *regcache, int rawnum); /* Transfer a raw register [0..NUM_REGS) between the regcache and the target. These functions are called by the target in response to a Index: sh-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/sh-tdep.c,v retrieving revision 1.66 diff -u -r1.66 sh-tdep.c --- sh-tdep.c 17 Jul 2002 18:43:28 -0000 1.66 +++ sh-tdep.c 22 Jul 2002 22:26:56 -0000 @@ -2251,11 +2251,12 @@ } #endif /* Note: must use write_register_gen here instead - of regcache_write, because regcache_write works - only for real registers, not pseudo. - write_register_gen will call the gdbarch - function to do register writes, and that will - properly know how to deal with pseudoregs. */ + of regcache_raw_write, because + regcache_raw_write works only for real + registers, not pseudo. write_register_gen will + call the gdbarch function to do register + writes, and that will properly know how to deal + with pseudoregs. */ write_register_gen (regnum, val); fp_args[double_arg_index] = 1; fp_args[double_arg_index + 1] = 1; @@ -3385,9 +3386,9 @@ /* Build the value in the provided buffer. */ /* Read the real regs for which this one is an alias. */ for (portion = 0; portion < 2; portion++) - regcache_read (current_regcache, base_regnum + portion, - (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + regcache_raw_read (current_regcache, base_regnum + portion, + (temp_buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); /* We must pay attention to the endiannes. */ sh_sh4_register_convert_to_virtual (reg_nr, REGISTER_VIRTUAL_TYPE (reg_nr), @@ -3400,8 +3401,8 @@ /* Read the real regs for which this one is an alias. */ for (portion = 0; portion < 4; portion++) - regcache_read (current_regcache, base_regnum + portion, - buffer + REGISTER_RAW_SIZE (base_regnum) * portion); + regcache_raw_read (current_regcache, base_regnum + portion, + buffer + REGISTER_RAW_SIZE (base_regnum) * portion); } } @@ -3410,7 +3411,7 @@ { if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM) /* It is a regular register. */ - regcache_read (current_regcache, reg_nr, buffer); + regcache_raw_read (current_regcache, reg_nr, buffer); else /* It is a pseudo register and we need to construct its value */ sh_pseudo_register_read (reg_nr, buffer); @@ -3434,9 +3435,9 @@ /* DR regs are double precision registers obtained by concatenating 2 single precision floating point registers. */ for (portion = 0; portion < 2; portion++) - regcache_read (current_regcache, base_regnum + portion, - (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + regcache_raw_read (current_regcache, base_regnum + portion, + (temp_buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); /* We must pay attention to the endiannes. */ sh_sh64_register_convert_to_virtual (reg_nr, REGISTER_VIRTUAL_TYPE (reg_nr), @@ -3453,8 +3454,9 @@ /* FPP regs are pairs of single precision registers obtained by concatenating 2 single precision floating point registers. */ for (portion = 0; portion < 2; portion++) - regcache_read (current_regcache, base_regnum + portion, - buffer + REGISTER_RAW_SIZE (base_regnum) * portion); + regcache_raw_read (current_regcache, base_regnum + portion, + (buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } else if (reg_nr >= tdep->FV0_REGNUM @@ -3466,8 +3468,9 @@ /* FV regs are vectors of single precision registers obtained by concatenating 4 single precision floating point registers. */ for (portion = 0; portion < 4; portion++) - regcache_read (current_regcache, base_regnum + portion, - buffer + REGISTER_RAW_SIZE (base_regnum) * portion); + regcache_raw_read (current_regcache, base_regnum + portion, + (buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } /* sh compact pseudo registers. 1-to-1 with a shmedia register */ @@ -3477,7 +3480,7 @@ base_regnum = sh64_compact_reg_base_num (reg_nr); /* Build the value in the provided buffer. */ - regcache_read (current_regcache, base_regnum, temp_buffer); + regcache_raw_read (current_regcache, base_regnum, temp_buffer); if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) offset = 4; memcpy (buffer, temp_buffer + offset, 4); /* get LOWER 32 bits only????*/ @@ -3491,7 +3494,7 @@ /* Build the value in the provided buffer. */ /* Floating point registers map 1-1 to the media fp regs, they have the same size and endienness. */ - regcache_read (current_regcache, base_regnum, buffer); + regcache_raw_read (current_regcache, base_regnum, buffer); } else if (reg_nr >= tdep->DR0_C_REGNUM @@ -3502,9 +3505,9 @@ /* DR_C regs are double precision registers obtained by concatenating 2 single precision floating point registers. */ for (portion = 0; portion < 2; portion++) - regcache_read (current_regcache, base_regnum + portion, - (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + regcache_raw_read (current_regcache, base_regnum + portion, + (temp_buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); /* We must pay attention to the endiannes. */ sh_sh64_register_convert_to_virtual (reg_nr, REGISTER_VIRTUAL_TYPE (reg_nr), @@ -3520,8 +3523,9 @@ /* FV_C regs are vectors of single precision registers obtained by concatenating 4 single precision floating point registers. */ for (portion = 0; portion < 4; portion++) - regcache_read (current_regcache, base_regnum + portion, - buffer + REGISTER_RAW_SIZE (base_regnum) * portion); + regcache_raw_read (current_regcache, base_regnum + portion, + (buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } else if (reg_nr == tdep->FPSCR_C_REGNUM) @@ -3552,11 +3556,11 @@ */ /* *INDENT-ON* */ /* Get FPSCR into a local buffer */ - regcache_read (current_regcache, fpscr_base_regnum, temp_buffer); + regcache_raw_read (current_regcache, fpscr_base_regnum, temp_buffer); /* Get value as an int. */ fpscr_value = extract_unsigned_integer (temp_buffer, 4); /* Get SR into a local buffer */ - regcache_read (current_regcache, sr_base_regnum, temp_buffer); + regcache_raw_read (current_regcache, sr_base_regnum, temp_buffer); /* Get value as an int. */ sr_value = extract_unsigned_integer (temp_buffer, 4); /* Build the new value. */ @@ -3574,7 +3578,7 @@ /* FPUL_C register is floating point register 32, same size, same endianness. */ - regcache_read (current_regcache, base_regnum, buffer); + regcache_raw_read (current_regcache, base_regnum, buffer); } } @@ -3584,7 +3588,7 @@ if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM) /* It is a regular register. */ - regcache_read (current_regcache, reg_nr, buffer); + regcache_raw_read (current_regcache, reg_nr, buffer); else /* It is a pseudo register and we need to construct its value */ sh64_pseudo_register_read (reg_nr, buffer); @@ -3608,9 +3612,9 @@ /* Write the real regs for which this one is an alias. */ for (portion = 0; portion < 2; portion++) - regcache_write (current_regcache, base_regnum + portion, - (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + regcache_raw_write (current_regcache, base_regnum + portion, + (temp_buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } else if (reg_nr >= tdep->FV0_REGNUM && reg_nr <= tdep->FV_LAST_REGNUM) @@ -3619,8 +3623,9 @@ /* Write the real regs for which this one is an alias. */ for (portion = 0; portion < 4; portion++) - regcache_write (current_regcache, base_regnum + portion, - buffer + REGISTER_RAW_SIZE (base_regnum) * portion); + regcache_raw_write (current_regcache, base_regnum + portion, + (buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } } @@ -3629,7 +3634,7 @@ { if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM) /* It is a regular register. */ - regcache_write (current_regcache, reg_nr, buffer); + regcache_raw_write (current_regcache, reg_nr, buffer); else /* It is a pseudo register and we need to construct its value */ sh_pseudo_register_write (reg_nr, buffer); @@ -3654,9 +3659,9 @@ /* Write the real regs for which this one is an alias. */ for (portion = 0; portion < 2; portion++) - regcache_write (current_regcache, base_regnum + portion, - (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + regcache_raw_write (current_regcache, base_regnum + portion, + (temp_buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } else if (reg_nr >= tdep->FPP0_REGNUM @@ -3666,8 +3671,9 @@ /* Write the real regs for which this one is an alias. */ for (portion = 0; portion < 2; portion++) - regcache_write (current_regcache, base_regnum + portion, - buffer + REGISTER_RAW_SIZE (base_regnum) * portion); + regcache_raw_write (current_regcache, base_regnum + portion, + (buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } else if (reg_nr >= tdep->FV0_REGNUM @@ -3677,8 +3683,9 @@ /* Write the real regs for which this one is an alias. */ for (portion = 0; portion < 4; portion++) - regcache_write (current_regcache, base_regnum + portion, - buffer + REGISTER_RAW_SIZE (base_regnum) * portion); + regcache_raw_write (current_regcache, base_regnum + portion, + (buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } /* sh compact general pseudo registers. 1-to-1 with a shmedia @@ -3695,10 +3702,10 @@ /* Let's read the value of the base register into a temporary buffer, so that overwriting the last four bytes with the new value of the pseudo will leave the upper 4 bytes unchanged. */ - regcache_read (current_regcache, base_regnum, temp_buffer); + regcache_raw_read (current_regcache, base_regnum, temp_buffer); /* Write as an 8 byte quantity */ memcpy (temp_buffer + offset, buffer, 4); - regcache_write (current_regcache, base_regnum, temp_buffer); + regcache_raw_write (current_regcache, base_regnum, temp_buffer); } /* sh floating point compact pseudo registers. 1-to-1 with a shmedia @@ -3707,7 +3714,7 @@ && reg_nr <= tdep->FP_LAST_C_REGNUM) { base_regnum = sh64_compact_reg_base_num (reg_nr); - regcache_write (current_regcache, base_regnum, buffer); + regcache_raw_write (current_regcache, base_regnum, buffer); } else if (reg_nr >= tdep->DR0_C_REGNUM @@ -3720,9 +3727,9 @@ sh_sh64_register_convert_to_raw (REGISTER_VIRTUAL_TYPE (reg_nr), reg_nr, buffer, temp_buffer); - regcache_write (current_regcache, base_regnum + portion, - (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + regcache_raw_write (current_regcache, base_regnum + portion, + (temp_buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } } @@ -3733,8 +3740,9 @@ for (portion = 0; portion < 4; portion++) { - regcache_write (current_regcache, base_regnum + portion, - buffer + REGISTER_RAW_SIZE (base_regnum) * portion); + regcache_raw_write (current_regcache, base_regnum + portion, + (buffer + + REGISTER_RAW_SIZE (base_regnum) * portion)); } } @@ -3776,25 +3784,25 @@ fpscr_value = fpscr_c_value & fpscr_mask; sr_value = (fpscr_value & sr_mask) >> 6; - regcache_read (current_regcache, fpscr_base_regnum, temp_buffer); + regcache_raw_read (current_regcache, fpscr_base_regnum, temp_buffer); old_fpscr_value = extract_unsigned_integer (temp_buffer, 4); old_fpscr_value &= 0xfffc0002; fpscr_value |= old_fpscr_value; store_unsigned_integer (temp_buffer, 4, fpscr_value); - regcache_write (current_regcache, fpscr_base_regnum, temp_buffer); + regcache_raw_write (current_regcache, fpscr_base_regnum, temp_buffer); - regcache_read (current_regcache, sr_base_regnum, temp_buffer); + regcache_raw_read (current_regcache, sr_base_regnum, temp_buffer); old_sr_value = extract_unsigned_integer (temp_buffer, 4); old_sr_value &= 0xffff8fff; sr_value |= old_sr_value; store_unsigned_integer (temp_buffer, 4, sr_value); - regcache_write (current_regcache, sr_base_regnum, temp_buffer); + regcache_raw_write (current_regcache, sr_base_regnum, temp_buffer); } else if (reg_nr == tdep->FPUL_C_REGNUM) { base_regnum = sh64_compact_reg_base_num (reg_nr); - regcache_write (current_regcache, base_regnum, buffer); + regcache_raw_write (current_regcache, base_regnum, buffer); } } @@ -3803,7 +3811,7 @@ { if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM) /* It is a regular register. */ - regcache_write (current_regcache, reg_nr, buffer); + regcache_raw_write (current_regcache, reg_nr, buffer); else /* It is a pseudo register and we need to construct its value */ sh64_pseudo_register_write (reg_nr, buffer); --------------070803080106030407060708--