From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 12745 invoked by alias); 21 Feb 2002 21:25:43 -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 12544 invoked from network); 21 Feb 2002 21:25:30 -0000 Received: from unknown (HELO cygnus.com) (205.180.230.5) by sources.redhat.com with SMTP; 21 Feb 2002 21:25:30 -0000 Received: from localhost.redhat.com (cse.cygnus.com [205.180.230.236]) by runyon.cygnus.com (8.8.7-cygnus/8.8.7) with ESMTP id NAA07757; Thu, 21 Feb 2002 13:25:21 -0800 (PST) Received: by localhost.redhat.com (Postfix, from userid 469) id 47C5611403; Thu, 21 Feb 2002 16:25:12 -0500 (EST) From: Elena Zannoni MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Message-ID: <15477.26039.907368.838837@localhost.redhat.com> Date: Thu, 21 Feb 2002 13:25:00 -0000 To: Kevin Buettner Cc: gdb-patches@sources.redhat.com Subject: Re: [RFA] ppc-linux-nat.c AltiVec regs ptrace In-Reply-To: <1020221153240.ZM2943@localhost.localdomain> References: <15476.1308.919907.110811@localhost.redhat.com> <1020221153240.ZM2943@localhost.localdomain> X-Mailer: VM 7.00 under Emacs 20.7.1 X-SW-Source: 2002-02/txt/msg00606.txt.bz2 Ok, here is the patch again [(N+1)th time!:-)] I actually went back and tried to figure out how I didn't catch the iteration problem. To my excuse (yeah, lame), I can say that running the gdb testsuite and printing out the names of fetch_ppc_registers and store_ppc_registers (which are the only callers of the vrregs fill/supply functions), I *never* see fetch_ppc_registers being called, and I see store_ppc_registers called only when you do an inferior function call. We know very well that by no means the gdb testsuite is complete (expecially wrt registers), but I think it is a fair sample of commonly used commands. Also, I don't have Altivec specific tests, so the vrregs fill/supply will bever be called during a testsuite run, but still, there is only a slim chance that those functions get used. I should do a real code inspection to see where/if gdb calls store/fetch registers with -1 as parameter, but I am too busy with other stuff at the moment. (No, 'info reg' and 'info all' don't do it either). Note the GNU/Linux change freebie! Elena 2002-02-21 Elena Zannoni * ppc-linux-nat.c (PTRACE_GETVRREGS, PTRACE_SETVRREGS): Define. (have_ptrace_getvrregs): Define for run time checks. (fetch_register, store_register): Fetch/store altivec register when needed. (fetch_altivec_register, store_altivec-register): New functions. (supply_vrregset, fill_vrregset): New functions. (fetch_altivec_registers, store_altivec_registers): New functions. (fetch_ppc_registers, store_ppc_registers): Fetch/store altivec registers as well. Use GNU/Linux where applicable. Index: ppc-linux-nat.c =================================================================== RCS file: /cvs/uberbaum/gdb/ppc-linux-nat.c,v retrieving revision 1.15 diff -u -p -r1.15 ppc-linux-nat.c --- ppc-linux-nat.c 2002/02/18 15:08:40 1.15 +++ ppc-linux-nat.c 2002/02/21 21:20:59 @@ -1,4 +1,4 @@ -/* PPC linux native support. +/* PPC GNU/Linux native support. Copyright 1988, 1989, 1991, 1992, 1994, 1996, 2000, 2001, 2002 Free Software Foundation, Inc. @@ -51,6 +51,56 @@ #define PTRACE_XFER_TYPE int #endif +/* Glibc's headers don't define PTRACE_GETVRREGS so we cannot use a + configure time check. Some older glibc's (for instance 2.2.1) + don't have a specific powerpc version of ptrace.h, and fall back on + a generic one. In such cases, sys/ptrace.h defines + PTRACE_GETFPXREGS and PTRACE_SETFPXREGS to the same numbers that + ppc kernel's asm/ptrace.h defines PTRACE_GETVRREGS and + PTRACE_SETVRREGS to be. This also makes a configury check pretty + much useless. */ + +/* These definitions should really come from the glibc header files, + but Glibc doesn't know about the vrregs yet. */ +#ifndef PTRACE_GETVRREGS +#define PTRACE_GETVRREGS 18 +#define PTRACE_SETVRREGS 19 +#endif + +/* This oddity is because the Linux kernel defines elf_vrregset_t as + an array of 33 16 bytes long elements. I.e. it leaves out vrsave. + However the PTRACE_GETVRREGS and PTRACE_SETVRREGS requests return + the vrsave as an extra 4 bytes at the end. I opted for creating a + flat array of chars, so that it is easier to manipulate for gdb. + + There are 32 vector registers 16 bytes longs, plus a VSCR register + which is only 4 bytes long, but is fetched as a 16 bytes + quantity. Up to here we have the elf_vrregset_t structure. + Appended to this there is space for the VRSAVE register: 4 bytes. + Even though this vrsave register is not included in the regset + typedef, it is handled by the ptrace requests. + + Note that GNU/Linux doesn't support little endian PPC hardware, + therefore the offset at which the real value of the VSCR register + is located will be always 12 bytes. + + The layout is like this (where x is the actual value of the vscr reg): */ + +/* *INDENT-OFF* */ +/* + |.|.|.|.|.....|.|.|.|.||.|.|.|x||.| + <-------> <-------><-------><-> + VR0 VR31 VSCR VRSAVE +*/ +/* *INDENT-ON* */ + +#define SIZEOF_VRREGS 33*16+4 + +typedef char gdb_vrregset_t[SIZEOF_VRREGS]; + +/* For runtime check of ptrace support for VRREGS. */ +int have_ptrace_getvrregs = 1; + int kernel_u_size (void) { @@ -109,7 +159,41 @@ ppc_ptrace_cannot_fetch_store_register ( return (ppc_register_u_addr (regno) == -1); } +/* The Linux kernel ptrace interface for AltiVec registers uses the + registers set mechanism, as opposed to the interface for all the + other registers, that stores/fetches each register individually. */ static void +fetch_altivec_register (int tid, int regno) +{ + int ret; + int offset = 0; + gdb_vrregset_t regs; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); + + ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s); + if (ret < 0) + { + if (errno == EIO) + { + have_ptrace_getvrregs = 0; + return; + } + perror_with_name ("Unable to fetch AltiVec register"); + } + + /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes + long on the hardware. We deal only with the lower 4 bytes of the + vector. VRSAVE is at the end of the array in a 4 bytes slot, so + there is no need to define an offset for it. */ + if (regno == (tdep->ppc_vrsave_regnum - 1)) + offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); + + supply_register (regno, + regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset); +} + +static void fetch_register (int tid, int regno) { /* This isn't really an address. But ptrace thinks of it as one. */ @@ -119,6 +203,22 @@ fetch_register (int tid, int regno) char *buf = alloca (MAX_REGISTER_RAW_SIZE); CORE_ADDR regaddr = ppc_register_u_addr (regno); + if (altivec_register_p (regno)) + { + /* If this is the first time through, or if it is not the first + time through, and we have comfirmed that there is kernel + support for such a ptrace request, then go and fetch the + register. */ + if (have_ptrace_getvrregs) + { + fetch_altivec_register (tid, regno); + return; + } + /* If we have discovered that there is no ptrace support for + AltiVec registers, fall through and return zeroes, because + regaddr will be -1 in this case. */ + } + if (regaddr == -1) { memset (buf, '\0', REGISTER_RAW_SIZE (regno)); /* Supply zeroes */ @@ -142,14 +242,59 @@ fetch_register (int tid, int regno) supply_register (regno, buf); } +static void +supply_vrregset (gdb_vrregset_t *vrregsetp) +{ + int i; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1; + int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); + int offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); + + for (i = 0; i < num_of_vrregs; i++) + { + /* The last 2 registers of this set are only 32 bit long, not + 128. However an offset is necessary only for VSCR because it + occupies a whole vector, while VRSAVE occupies a full 4 bytes + slot. */ + if (i == (num_of_vrregs - 2)) + supply_register (tdep->ppc_vr0_regnum + i, + *vrregsetp + i * vrregsize + offset); + else + supply_register (tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize); + } +} + +static void +fetch_altivec_registers (int tid) +{ + int ret; + gdb_vrregset_t regs; + + ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s); + if (ret < 0) + { + if (errno == EIO) + { + have_ptrace_getvrregs = 0; + return; + } + perror_with_name ("Unable to fetch AltiVec registers"); + } + supply_vrregset (®s); +} + static void fetch_ppc_registers (int tid) { int i; - int last_register = gdbarch_tdep (current_gdbarch)->ppc_mq_regnum; - - for (i = 0; i <= last_register; i++) + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + + for (i = 0; i <= tdep->ppc_mq_regnum; i++) fetch_register (tid, i); + if (have_ptrace_getvrregs) + if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1) + fetch_altivec_registers (tid); } /* Fetch registers from the child process. Fetch all registers if @@ -158,14 +303,14 @@ fetch_ppc_registers (int tid) void fetch_inferior_registers (int regno) { - /* Overload thread id onto process id */ + /* Overload thread id onto process id */ int tid = TIDGET (inferior_ptid); /* No thread id, just use process id */ if (tid == 0) tid = PIDGET (inferior_ptid); - if (regno == -1) + if (regno == -1) fetch_ppc_registers (tid); else fetch_register (tid, regno); @@ -173,6 +318,39 @@ fetch_inferior_registers (int regno) /* Store one register. */ static void +store_altivec_register (int tid, int regno) +{ + int ret; + int offset = 0; + gdb_vrregset_t regs; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); + + ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s); + if (ret < 0) + { + if (errno == EIO) + { + have_ptrace_getvrregs = 0; + return; + } + perror_with_name ("Unable to fetch AltiVec register"); + } + + /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes + long on the hardware. */ + if (regno == (tdep->ppc_vrsave_regnum - 1)) + offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); + + regcache_collect (regno, + regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset); + + ret = ptrace (PTRACE_SETVRREGS, tid, 0, ®s); + if (ret < 0) + perror_with_name ("Unable to store AltiVec register"); +} + +static void store_register (int tid, int regno) { /* This isn't really an address. But ptrace thinks of it as one. */ @@ -182,11 +360,15 @@ store_register (int tid, int regno) unsigned int offset; /* Offset of registers within the u area. */ char *buf = alloca (MAX_REGISTER_RAW_SIZE); - if (regaddr == -1) + if (altivec_register_p (regno)) { + store_altivec_register (tid, regno); return; } + if (regaddr == -1) + return; + regcache_collect (regno, buf); for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) { @@ -204,13 +386,60 @@ store_register (int tid, int regno) } static void +fill_vrregset (gdb_vrregset_t *vrregsetp) +{ + int i; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1; + int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); + int offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); + + for (i = 0; i < num_of_vrregs; i++) + { + /* The last 2 registers of this set are only 32 bit long, not + 128, but only VSCR is fetched as a 16 bytes quantity. */ + if (i == (num_of_vrregs - 2)) + regcache_collect (tdep->ppc_vr0_regnum + i, + *vrregsetp + i * vrregsize + offset); + else + regcache_collect (tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize); + } +} + +static void +store_altivec_registers (int tid) +{ + int ret; + gdb_vrregset_t regs; + + ret = ptrace (PTRACE_GETVRREGS, tid, 0, (int) ®s); + if (ret < 0) + { + if (errno == EIO) + { + have_ptrace_getvrregs = 0; + return; + } + perror_with_name ("Couldn't get AltiVec registers"); + } + + fill_vrregset (®s); + + if (ptrace (PTRACE_SETVRREGS, tid, 0, (int) ®s) < 0) + perror_with_name ("Couldn't write AltiVec registers"); +} + +static void store_ppc_registers (int tid) { int i; - int last_register = gdbarch_tdep (current_gdbarch)->ppc_mq_regnum; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - for (i = 0; i <= last_register; i++) + for (i = 0; i <= tdep->ppc_mq_regnum; i++) store_register (tid, i); + if (have_ptrace_getvrregs) + if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1) + store_altivec_registers (tid); } void @@ -281,15 +510,15 @@ void supply_fpregset (gdb_fpregset_t * fpregsetp) { int regi; + for (regi = 0; regi < 32; regi++) supply_register (FP0_REGNUM + regi, (char *) (*fpregsetp + regi)); } - -/* Given a pointer to a floating point register set in /proc format - (fpregset_t *), update the register specified by REGNO from gdb's idea - of the current floating point register set. If REGNO is -1, update - them all. */ +/* Given a pointer to a floating point register set in /proc format + (fpregset_t *), update the register specified by REGNO from gdb's + idea of the current floating point register set. If REGNO is -1, + update them all. */ void fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) {