From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 6911 invoked by alias); 2 Jun 2003 18:27:54 -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 6735 invoked from network); 2 Jun 2003 18:27:51 -0000 Received: from unknown (HELO are.twiddle.net) (64.81.246.98) by sources.redhat.com with SMTP; 2 Jun 2003 18:27:51 -0000 Received: from kanga.twiddle.net (kanga.twiddle.home [172.31.0.3]) by are.twiddle.net (8.12.8/8.12.8) with ESMTP id h52IRpLH010078 for ; Mon, 2 Jun 2003 11:27:51 -0700 Received: from rth by kanga.twiddle.net with local (Exim 3.36 #1 (Debian)) id 19MtuD-0003w8-00 for ; Mon, 02 Jun 2003 11:19:37 -0700 Date: Mon, 02 Jun 2003 18:27:00 -0000 To: gdb-patches@sources.redhat.com Subject: [RFA] cleanup alpha core read/write registers Message-ID: <20030602181937.GA15118@twiddle.net> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline User-Agent: Mutt/1.5.4i From: Richard Henderson X-SW-Source: 2003-06/txt/msg00076.txt.bz2 RFA because I'm touching systems I can't test. As far as alpha-nat is concerned, this gets rid of the use of the deprecated register array. Indeed, there are no longer *any* instances of "deprecated" in the alpha port. As far as Linux is concerned, this fixes the gcore test because we now properly dump the FPCR and UNIQUE registers. As far as the BSD's are concerned, this should be a no-op, just avoiding some amount of code duplication. Ok? r~ * alpha-nat.c: Remove all instances of "register". (zerobuf): Move out from subroutines. (fetch_elf_core_registers): Use supply_register. (supply_gregset): Use alpha-specific register macros; supply ALPHA_UNIQUE_REGNUM if the gregset is large enough. (fill_gregset): Similarly. Use regcache_collect. (supply_fpregset): Use alpha-specific register macros. (fill_fpregset): Similarly. Use regcache_collect. Index: alpha-nat.c =================================================================== RCS file: /cvs/src/src/gdb/alpha-nat.c,v retrieving revision 1.18 diff -c -p -d -r1.18 alpha-nat.c *** alpha-nat.c 1 Jun 2003 21:46:37 -0000 1.18 --- alpha-nat.c 2 Jun 2003 17:01:58 -0000 *************** *** 42,47 **** --- 42,49 ---- static void fetch_osf_core_registers (char *, unsigned, int, CORE_ADDR); static void fetch_elf_core_registers (char *, unsigned, int, CORE_ADDR); + static const char zerobuf[ALPHA_REGISTER_SIZE] = {0}; + /* Extract the register values out of the core file and store them where `read_register' will find them. *************** static void *** 59,66 **** fetch_osf_core_registers (char *core_reg_sect, unsigned core_reg_size, int which, CORE_ADDR reg_addr) { ! register int regno; ! register int addr; int bad_reg = -1; /* Table to map a gdb regnum to an index in the core register --- 61,68 ---- fetch_osf_core_registers (char *core_reg_sect, unsigned core_reg_size, int which, CORE_ADDR reg_addr) { ! int regno; ! int addr; int bad_reg = -1; /* Table to map a gdb regnum to an index in the core register *************** fetch_osf_core_registers (char *core_reg *** 94,100 **** EF_PC, -1 #endif }; - static char zerobuf[ALPHA_REGISTER_SIZE] = {0}; for (regno = 0; regno < NUM_REGS; regno++) { --- 96,101 ---- *************** static void *** 124,129 **** --- 125,132 ---- fetch_elf_core_registers (char *core_reg_sect, unsigned core_reg_size, int which, CORE_ADDR reg_addr) { + int i; + if (core_reg_size < 32 * 8) { error ("Core file register section too small (%u bytes).", core_reg_size); *************** fetch_elf_core_registers (char *core_reg *** 132,164 **** if (which == 2) { ! /* The FPU Registers. */ ! memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], ! core_reg_sect, 31 * 8); ! memset (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 31)], 0, 8); ! memset (&deprecated_register_valid[FP0_REGNUM], 1, 32); } else { /* The General Registers. */ ! memcpy (&deprecated_registers[REGISTER_BYTE (ALPHA_V0_REGNUM)], ! core_reg_sect, 31 * 8); ! memcpy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)], ! core_reg_sect + 31 * 8, 8); ! memset (&deprecated_registers[REGISTER_BYTE (ALPHA_ZERO_REGNUM)], 0, 8); ! memset (&deprecated_register_valid[ALPHA_V0_REGNUM], 1, 32); ! deprecated_register_valid[PC_REGNUM] = 1; if (core_reg_size >= 33 * 8) ! { ! memcpy (&deprecated_registers[REGISTER_BYTE (ALPHA_UNIQUE_REGNUM)], ! core_reg_sect + 32 * 8, 8); ! deprecated_register_valid[ALPHA_UNIQUE_REGNUM] = 1; ! } } } - /* Map gdb internal register number to a ptrace ``address''. These ``addresses'' are defined in , with the exception of ALPHA_UNIQUE_PTRACE_ADDR. */ --- 135,158 ---- if (which == 2) { ! /* The Floating Point Registers. */ ! for (i = 0; i < 31; ++i) ! supply_register (ALPHA_FP0_REGNUM + i, core_reg_sect + i * 8); ! supply_register (ALPHA_FPCR_REGNUM, core_reg_sect + 31 * 8); } else { /* The General Registers. */ ! for (i = 0; i < 31; ++i) ! supply_register (ALPHA_V0_REGNUM + i, core_reg_sect + i * 8); ! supply_register (ALPHA_ZERO_REGNUM, zerobuf); ! supply_register (ALPHA_PC_REGNUM, core_reg_sect + 31 * 8); if (core_reg_size >= 33 * 8) ! supply_register (ALPHA_UNIQUE_REGNUM, core_reg_sect + 32 * 8); } } /* Map gdb internal register number to a ptrace ``address''. These ``addresses'' are defined in , with the exception of ALPHA_UNIQUE_PTRACE_ADDR. */ *************** kernel_u_size (void) *** 199,212 **** void supply_gregset (gdb_gregset_t *gregsetp) { ! register int regi; ! register long *regp = ALPHA_REGSET_BASE (gregsetp); ! static char zerobuf[ALPHA_REGISTER_SIZE] = {0}; for (regi = 0; regi < 31; regi++) ! supply_register (regi, (char *) (regp + regi)); ! supply_register (PC_REGNUM, (char *) (regp + 31)); /* Fill inaccessible registers with zero. */ supply_register (ALPHA_ZERO_REGNUM, zerobuf); --- 193,208 ---- void supply_gregset (gdb_gregset_t *gregsetp) { ! int regi; ! long *regp = ALPHA_REGSET_BASE (gregsetp); for (regi = 0; regi < 31; regi++) ! supply_register (regi, regp + regi); ! supply_register (ALPHA_PC_REGNUM, regp + 31); ! ! if (sizeof (*gregsetp) >= 33 * 8) ! supply_register (ALPHA_UNIQUE_REGNUM, regp + 32); /* Fill inaccessible registers with zero. */ supply_register (ALPHA_ZERO_REGNUM, zerobuf); *************** void *** 216,229 **** fill_gregset (gdb_gregset_t *gregsetp, int regno) { int regi; ! register long *regp = ALPHA_REGSET_BASE (gregsetp); for (regi = 0; regi < 31; regi++) ! if ((regno == -1) || (regno == regi)) ! *(regp + regi) = *(long *) &deprecated_registers[REGISTER_BYTE (regi)]; ! if ((regno == -1) || (regno == PC_REGNUM)) ! *(regp + 31) = *(long *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)]; } /* --- 212,229 ---- fill_gregset (gdb_gregset_t *gregsetp, int regno) { int regi; ! long *regp = ALPHA_REGSET_BASE (gregsetp); for (regi = 0; regi < 31; regi++) ! if (regno == -1 || regno == regi) ! regcache_collect (regi, regp + regi); ! if (regno == -1 || regno == ALPHA_PC_REGNUM) ! regcache_collect (ALPHA_PC_REGNUM, regp + 31); ! ! if (sizeof (*gregsetp) >= 33 * 8 ! && (regno == -1 || regno == ALPHA_UNIQUE_REGNUM)) ! regcache_collect (ALPHA_UNIQUE_REGNUM, regp + 32); } /* *************** fill_gregset (gdb_gregset_t *gregsetp, i *** 234,260 **** void supply_fpregset (gdb_fpregset_t *fpregsetp) { ! register int regi; ! register long *regp = ALPHA_REGSET_BASE (fpregsetp); ! for (regi = 0; regi < 32; regi++) ! supply_register (regi + FP0_REGNUM, (char *) (regp + regi)); } void fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) { int regi; ! register long *regp = ALPHA_REGSET_BASE (fpregsetp); ! for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++) ! { ! if ((regno == -1) || (regno == regi)) ! { ! *(regp + regi - FP0_REGNUM) = ! *(long *) &deprecated_registers[REGISTER_BYTE (regi)]; ! } ! } } #endif --- 234,260 ---- void supply_fpregset (gdb_fpregset_t *fpregsetp) { ! int regi; ! long *regp = ALPHA_REGSET_BASE (fpregsetp); ! for (regi = 0; regi < 31; regi++) ! supply_register (regi + ALPHA_FP0_REGNUM, regp + regi); ! ! supply_register (ALPHA_FPCR_REGNUM, regp + 31); } void fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) { int regi; ! long *regp = ALPHA_REGSET_BASE (fpregsetp); ! for (regi = ALPHA_FP0_REGNUM; regi < ALPHA_FP0_REGNUM+31; regi++) ! if (regno == -1 || regno == regi) ! regcache_collect (regi, regp + regi - ALPHA_FP0_REGNUM); ! ! if (regno == -1 || regno == ALPHA_FPCR_REGNUM) ! regcache_collect (ALPHA_FPCR_REGNUM, regp + 31); } #endif