From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 11403 invoked by alias); 4 Aug 2010 07:32:53 -0000 Received: (qmail 11387 invoked by uid 22791); 4 Aug 2010 07:32:51 -0000 X-SWARE-Spam-Status: No, hits=-1.6 required=5.0 tests=AWL,BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,TW_CP,TW_EG,TW_FN,TW_GJ,TW_OC X-Spam-Check-By: sourceware.org Received: from mail-wy0-f169.google.com (HELO mail-wy0-f169.google.com) (74.125.82.169) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 04 Aug 2010 07:32:44 +0000 Received: by wyg36 with SMTP id 36so5778700wyg.0 for ; Wed, 04 Aug 2010 00:32:42 -0700 (PDT) Received: by 10.216.17.72 with SMTP id i50mr1677391wei.77.1280907162192; Wed, 04 Aug 2010 00:32:42 -0700 (PDT) MIME-Version: 1.0 Received: by 10.216.186.205 with HTTP; Wed, 4 Aug 2010 00:32:22 -0700 (PDT) From: Hui Zhu Date: Wed, 04 Aug 2010 07:32:00 -0000 Message-ID: Subject: [PATCH] mips-linux: remove deprecated_add_core_fns and use set_gdbarch_regset_from_core_section To: gdb-patches ml Cc: Ulrich Weigand Content-Type: text/plain; charset=ISO-8859-1 X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2010-08/txt/msg00016.txt.bz2 Hi, According to the comments of Ulrich in http://sourceware.org/ml/gdb/2010-08/msg00022.html I make this patch to remove deprecated_add_core_fns from mips-linux and use set_gdbarch_regset_from_core_section to make mips-linux support multi-arch and core better. I test this patch in mips-n32 host with core-file and gcore and test a mips64 core that kdump generate. All of them are work OK. Thanks, Hui 2010-08-04 Hui Zhu * mips-linux-tdep.c(regset.h): New include. (mips_supply_gregset_wrapper, mips_fill_gregset_wrapper, mips_supply_fpregset_wrapper, mips_fill_fpregset_wrapper, mips64_supply_gregset_wrapper, mips64_fill_gregset_wrapper, mips64_supply_fpregset_wrapper, mips64_fill_fpregset_wrapper, mips_linux_regset_from_core_section): New functions. (fetch_core_registers, regset_core_fns): Deleted. (mips_linux_init_abi): Add mips_linux_regset_from_core_section. Deleted regset_core_fns. * mips-tdep.c(mips_gdbarch_init): Initialize tdep->gregset, tdep->gregset64, tdep->fpregset and tdep->fpregset64. * mips-tdep.h(gdbarch_tdep): Add gregset, gregset64, fpregset and fpregset64. --- mips-linux-tdep.c | 153 ++++++++++++++++++++++++++++++++++++++++-------------- mips-tdep.c | 4 + mips-tdep.h | 8 ++ 3 files changed, 126 insertions(+), 39 deletions(-) --- a/mips-linux-tdep.c +++ b/mips-linux-tdep.c @@ -36,6 +36,7 @@ #include "solist.h" #include "symtab.h" #include "target-descriptions.h" +#include "regset.h" #include "mips-linux-tdep.h" #include "glibc-tdep.h" @@ -126,6 +127,16 @@ mips_supply_gregset (struct regcache *re regcache_raw_supply (regcache, regi, zerobuf); } +static void +mips_supply_gregset_wrapper (const struct regset *regset, + struct regcache *regcache, + int regnum, const void *gregs, size_t len) +{ + gdb_assert (len == sizeof (mips_elf_gregset_t)); + + mips_supply_gregset (regcache, (const mips_elf_gregset_t *)gregs); +} + /* Pack our registers (or one register) into an elf_gregset_t. */ void @@ -184,6 +195,16 @@ mips_fill_gregset (const struct regcache } } +static void +mips_fill_gregset_wrapper (const struct regset *regset, + const struct regcache *regcache, + int regnum, void *gregs, size_t len) +{ + gdb_assert (len == sizeof (mips_elf_gregset_t)); + + mips_fill_gregset (regcache, (mips_elf_gregset_t *)gregs, regnum); +} + /* Likewise, unpack an elf_fpregset_t. */ void @@ -211,6 +232,16 @@ mips_supply_fpregset (struct regcache *r zerobuf); } +static void +mips_supply_fpregset_wrapper (const struct regset *regset, + struct regcache *regcache, + int regnum, const void *gregs, size_t len) +{ + gdb_assert (len == sizeof (mips_elf_fpregset_t)); + + mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *)gregs); +} + /* Likewise, pack one or all floating point registers into an elf_fpregset_t. */ @@ -244,6 +275,16 @@ mips_fill_fpregset (const struct regcach } } +static void +mips_fill_fpregset_wrapper (const struct regset *regset, + const struct regcache *regcache, + int regnum, void *gregs, size_t len) +{ + gdb_assert (len == sizeof (mips_elf_fpregset_t)); + + mips_fill_fpregset (regcache, (mips_elf_fpregset_t *)gregs, regnum); +} + /* Support for 64-bit ABIs. */ /* Figure out where the longjmp will land. @@ -341,6 +382,16 @@ mips64_supply_gregset (struct regcache * regcache_raw_supply (regcache, regi, zerobuf); } +static void +mips64_supply_gregset_wrapper (const struct regset *regset, + struct regcache *regcache, + int regnum, const void *gregs, size_t len) +{ + gdb_assert (len == sizeof (mips64_elf_gregset_t)); + + mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *)gregs); +} + /* Pack our registers (or one register) into a 64-bit elf_gregset_t. */ void @@ -401,6 +452,16 @@ mips64_fill_gregset (const struct regcac } } +static void +mips64_fill_gregset_wrapper (const struct regset *regset, + const struct regcache *regcache, + int regnum, void *gregs, size_t len) +{ + gdb_assert (len == sizeof (mips64_elf_gregset_t)); + + mips64_fill_gregset (regcache, (mips64_elf_gregset_t *)gregs, regnum); +} + /* Likewise, unpack an elf_fpregset_t. */ void @@ -439,6 +500,16 @@ mips64_supply_fpregset (struct regcache (const gdb_byte *)(*fpregsetp + 32) + 4); } +static void +mips64_supply_fpregset_wrapper (const struct regset *regset, + struct regcache *regcache, + int regnum, const void *gregs, size_t len) +{ + gdb_assert (len == sizeof (mips64_elf_fpregset_t)); + + mips64_supply_fpregset (regcache, (const mips64_elf_fpregset_t *)gregs); +} + /* Likewise, pack one or all floating point registers into an elf_fpregset_t. */ @@ -507,72 +578,75 @@ mips64_fill_fpregset (const struct regca } } +static void +mips64_fill_fpregset_wrapper (const struct regset *regset, + const struct regcache *regcache, + int regnum, void *gregs, size_t len) +{ + gdb_assert (len == sizeof (mips64_elf_fpregset_t)); -/* Use a local version of this function to get the correct types for - regsets, until multi-arch core support is ready. */ + mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *)gregs, regnum); +} -static void -fetch_core_registers (struct regcache *regcache, - char *core_reg_sect, unsigned core_reg_size, - int which, CORE_ADDR reg_addr) +const struct regset * +mips_linux_regset_from_core_section (struct gdbarch *gdbarch, + const char *sect_name, size_t sect_size) { + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); mips_elf_gregset_t gregset; mips_elf_fpregset_t fpregset; mips64_elf_gregset_t gregset64; mips64_elf_fpregset_t fpregset64; - if (which == 0) + if (strcmp (sect_name, ".reg") == 0) { - if (core_reg_size == sizeof (gregset)) + if (sect_size == sizeof (gregset)) { - memcpy ((char *) &gregset, core_reg_sect, sizeof (gregset)); - mips_supply_gregset (regcache, - (const mips_elf_gregset_t *) &gregset); + if (tdep->gregset == NULL) + tdep->gregset = regset_alloc (gdbarch, + mips_supply_gregset_wrapper, + mips_fill_gregset_wrapper); + return tdep->gregset; } - else if (core_reg_size == sizeof (gregset64)) + else if (sect_size == sizeof (gregset64)) { - memcpy ((char *) &gregset64, core_reg_sect, sizeof (gregset64)); - mips64_supply_gregset (regcache, - (const mips64_elf_gregset_t *) &gregset64); + if (tdep->gregset64 == NULL) + tdep->gregset64 = regset_alloc (gdbarch, + mips64_supply_gregset_wrapper, + mips64_fill_gregset_wrapper); + return tdep->gregset64; } else { warning (_("wrong size gregset struct in core file")); } } - else if (which == 2) + else if (strcmp (sect_name, ".reg2") == 0) { - if (core_reg_size == sizeof (fpregset)) + if (sect_size == sizeof (fpregset)) { - memcpy ((char *) &fpregset, core_reg_sect, sizeof (fpregset)); - mips_supply_fpregset (regcache, - (const mips_elf_fpregset_t *) &fpregset); + if (tdep->fpregset == NULL) + tdep->fpregset = regset_alloc (gdbarch, + mips_supply_fpregset_wrapper, + mips_fill_fpregset_wrapper); + return tdep->fpregset; } - else if (core_reg_size == sizeof (fpregset64)) + else if (sect_size == sizeof (fpregset64)) { - memcpy ((char *) &fpregset64, core_reg_sect, - sizeof (fpregset64)); - mips64_supply_fpregset (regcache, - (const mips64_elf_fpregset_t *) &fpregset64); + if (tdep->fpregset64 == NULL) + tdep->fpregset64 = regset_alloc (gdbarch, + mips64_supply_fpregset_wrapper, + mips64_fill_fpregset_wrapper); + return tdep->fpregset64; } else { warning (_("wrong size fpregset struct in core file")); } } -} -/* Register that we are able to handle ELF file formats using standard - procfs "regset" structures. */ - -static struct core_fns regset_core_fns = -{ - bfd_target_elf_flavour, /* core_flavour */ - default_check_format, /* check_format */ - default_core_sniffer, /* core_sniffer */ - fetch_core_registers, /* core_read_registers */ - NULL /* next */ -}; + return NULL; +} static const struct target_desc * mips_linux_core_read_description (struct gdbarch *gdbarch, @@ -1203,6 +1277,9 @@ mips_linux_init_abi (struct gdbarch_info set_gdbarch_core_read_description (gdbarch, mips_linux_core_read_description); + set_gdbarch_regset_from_core_section (gdbarch, + mips_linux_regset_from_core_section); + tdep->syscall_next_pc = mips_linux_syscall_next_pc; if (tdesc_data) @@ -1240,6 +1317,4 @@ _initialize_mips_linux_tdep (void) GDB_OSABI_LINUX, mips_linux_init_abi); } - - deprecated_add_core_fns (®set_core_fns); } --- a/mips-tdep.c +++ b/mips-tdep.c @@ -5749,6 +5749,10 @@ mips_gdbarch_init (struct gdbarch_info i tdep->mips_fpu_type = fpu_type; tdep->register_size_valid_p = 0; tdep->register_size = 0; + tdep->gregset = NULL; + tdep->gregset64 = NULL; + tdep->fpregset = NULL; + tdep->fpregset64 = NULL; if (info.target_desc) { --- a/mips-tdep.h +++ b/mips-tdep.h @@ -97,6 +97,14 @@ struct gdbarch_tdep int register_size_valid_p; int register_size; + /* General-purpose registers. */ + struct regset *gregset; + struct regset *gregset64; + + /* Floating-point registers. */ + struct regset *fpregset; + struct regset *fpregset64; + /* Return the expected next PC if FRAME is stopped at a syscall instruction. */ CORE_ADDR (*syscall_next_pc) (struct frame_info *frame);