From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 8666 invoked by alias); 28 Jun 2005 00:41:09 -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 8635 invoked by uid 22791); 28 Jun 2005 00:40:59 -0000 Received: from mx1.redhat.com (HELO mx1.redhat.com) (66.187.233.31) by sourceware.org (qpsmtpd/0.30-dev) with ESMTP; Tue, 28 Jun 2005 00:40:59 +0000 Received: from int-mx1.corp.redhat.com (int-mx1.corp.redhat.com [172.16.52.254]) by mx1.redhat.com (8.12.11/8.12.11) with ESMTP id j5S0eNEq013800 for ; Mon, 27 Jun 2005 20:40:28 -0400 Received: from potter.sfbay.redhat.com (potter.sfbay.redhat.com [172.16.27.15]) by int-mx1.corp.redhat.com (8.11.6/8.11.6) with ESMTP id j5S0eMu15143; Mon, 27 Jun 2005 20:40:22 -0400 Received: from [172.16.24.50] (bluegiant.sfbay.redhat.com [172.16.24.50]) by potter.sfbay.redhat.com (8.12.8/8.12.8) with ESMTP id j5S0eKWM023401; Mon, 27 Jun 2005 20:40:21 -0400 Message-ID: <42C09C74.1010507@redhat.com> Date: Tue, 28 Jun 2005 00:41:00 -0000 From: Michael Snyder User-Agent: Mozilla Thunderbird (X11/20050322) MIME-Version: 1.0 To: GDB Patches , mark.kettenis@xs4all.nl, drow@false.org Subject: [RFA] Take III, part 2: am33 linux corefile support Content-Type: multipart/mixed; boundary="------------050707080202000006060206" X-Virus-Checked: Checked by ClamAV on sourceware.org X-SW-Source: 2005-06/txt/msg00373.txt.bz2 This is a multi-part message in MIME format. --------------050707080202000006060206 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Content-length: 165 OK, here's this part again. Mark, I used the osabi mechanism to register my corefile handlers, and I changed the typedefs from unsigned char to gdb_byte. Michael --------------050707080202000006060206 Content-Type: text/plain; name="stage2" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="stage2" Content-length: 20460 2005-06-27 Michael Snyder * mn10300-linux-tdep.c: New file. OSABI sniffer at end. * Makefile.in: Add rule for mn10300-linux-tdep.c. * config/mn10300/linux.mt: Add mn10300-linux-tdep.c to tdep files. Index: config/mn10300/linux.mt =================================================================== RCS file: /cvs/src/src/gdb/config/mn10300/linux.mt,v retrieving revision 1.1 diff -p -r1.1 linux.mt *** config/mn10300/linux.mt 28 Jun 2005 00:17:50 -0000 1.1 --- config/mn10300/linux.mt 28 Jun 2005 00:39:24 -0000 *************** *** 1,3 **** # Target: Matsushita mn10300 (AM33) running Linux ! TDEPFILES= mn10300-tdep.o solib.o solib-svr4.o --- 1,3 ---- # Target: Matsushita mn10300 (AM33) running Linux ! TDEPFILES= mn10300-tdep.o mn10300-linux-tdep.o corelow.o solib.o solib-svr4.o Index: Makefile.in =================================================================== RCS file: /cvs/src/src/gdb/Makefile.in,v retrieving revision 1.738 diff -p -r1.738 Makefile.in *** Makefile.in 25 Jun 2005 11:54:29 -0000 1.738 --- Makefile.in 28 Jun 2005 00:39:25 -0000 *************** mips-tdep.o: mips-tdep.c $(defs_h) $(gdb *** 2307,2312 **** --- 2307,2314 ---- $(floatformat_h) mipsv4-nat.o: mipsv4-nat.c $(defs_h) $(inferior_h) $(gdbcore_h) $(target_h) \ $(regcache_h) $(gregset_h) + mn10300-linux-tdep.o: mn10300-linux-tdep.c $(defs_h) $(gdbcore_h) \ + $(gdb_string_h) $(regcache_h) $(mn10300_tdep_h) mn10300-tdep.o: mn10300-tdep.c $(defs_h) $(arch_utils_h) $(dis_asm_h) \ $(gdbtypes_h) $(regcache_h) $(gdb_string_h) $(gdb_assert_h) \ $(frame_h) $(frame_unwind_h) $(frame_base_h) $(trad_frame_h) \ Index: mn10300-linux-tdep.c =================================================================== RCS file: mn10300-linux-tdep.c diff -N mn10300-linux-tdep.c *** /dev/null 1 Jan 1970 00:00:00 -0000 --- mn10300-linux-tdep.c 28 Jun 2005 00:39:25 -0000 *************** *** 0 **** --- 1,504 ---- + /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger. + Copyright 2003, 2004, 2005 + Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + + #include "defs.h" + #include "gdbcore.h" + #include "gdb_string.h" + #include "regcache.h" + #include "mn10300-tdep.h" + #include "gdb_assert.h" + #include "bfd.h" + #include "elf-bfd.h" + #include "osabi.h" + + #include + + /* Transliterated from ... */ + #define ELF_NGREG 27 + #define ELF_NFPREG 32 + + typedef gdb_byte elf_greg_t[4]; + typedef elf_greg_t elf_gregset_t[ELF_NGREG]; + + typedef gdb_byte elf_fpreg_t[4]; + typedef struct + { + elf_fpreg_t fpregs[ELF_NFPREG]; + gdb_byte fpcr[4]; + } elf_fpregset_t; + + /* elf_gregset_t register indices stolen from include/asm-mn10300/ptrace.h. */ + #define ELF_GREGSET_T_REG_INDEX_A3 0 + #define ELF_GREGSET_T_REG_INDEX_A2 1 + #define ELF_GREGSET_T_REG_INDEX_D3 2 + #define ELF_GREGSET_T_REG_INDEX_D2 3 + #define ELF_GREGSET_T_REG_INDEX_MCVF 4 + #define ELF_GREGSET_T_REG_INDEX_MCRL 5 + #define ELF_GREGSET_T_REG_INDEX_MCRH 6 + #define ELF_GREGSET_T_REG_INDEX_MDRQ 7 + #define ELF_GREGSET_T_REG_INDEX_E1 8 + #define ELF_GREGSET_T_REG_INDEX_E0 9 + #define ELF_GREGSET_T_REG_INDEX_E7 10 + #define ELF_GREGSET_T_REG_INDEX_E6 11 + #define ELF_GREGSET_T_REG_INDEX_E5 12 + #define ELF_GREGSET_T_REG_INDEX_E4 13 + #define ELF_GREGSET_T_REG_INDEX_E3 14 + #define ELF_GREGSET_T_REG_INDEX_E2 15 + #define ELF_GREGSET_T_REG_INDEX_SP 16 + #define ELF_GREGSET_T_REG_INDEX_LAR 17 + #define ELF_GREGSET_T_REG_INDEX_LIR 18 + #define ELF_GREGSET_T_REG_INDEX_MDR 19 + #define ELF_GREGSET_T_REG_INDEX_A1 20 + #define ELF_GREGSET_T_REG_INDEX_A0 21 + #define ELF_GREGSET_T_REG_INDEX_D1 22 + #define ELF_GREGSET_T_REG_INDEX_D0 23 + #define ELF_GREGSET_T_REG_INDEX_ORIG_D0 24 + #define ELF_GREGSET_T_REG_INDEX_EPSW 25 + #define ELF_GREGSET_T_REG_INDEX_PC 26 + + /* New gdbarch API for corefile registers. + Given a section name and size, create a struct reg object + with a supply_register and a collect_register method. */ + + /* Copy register value of REGNUM from regset to regcache. + If REGNUM is -1, do this for all gp registers in regset. */ + + static void + am33_supply_gregset_method (const struct regset *regset, + struct regcache *regcache, + int regnum, const void *gregs, size_t len) + { + char zerobuf[MAX_REGISTER_SIZE]; + elf_gregset_t *regp = gregs; + int i; + + gdb_assert (len == sizeof (elf_gregset_t)); + + switch (regnum) { + case E_D0_REGNUM: + regcache_raw_supply (regcache, E_D0_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_D0)); + break; + case E_D1_REGNUM: + regcache_raw_supply (regcache, E_D1_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_D1)); + break; + case E_D2_REGNUM: + regcache_raw_supply (regcache, E_D2_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_D2)); + break; + case E_D3_REGNUM: + regcache_raw_supply (regcache, E_D3_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_D3)); + break; + case E_A0_REGNUM: + regcache_raw_supply (regcache, E_A0_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_A0)); + break; + case E_A1_REGNUM: + regcache_raw_supply (regcache, E_A1_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_A1)); + break; + case E_A2_REGNUM: + regcache_raw_supply (regcache, E_A2_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_A2)); + break; + case E_A3_REGNUM: + regcache_raw_supply (regcache, E_A3_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_A3)); + break; + case E_SP_REGNUM: + regcache_raw_supply (regcache, E_SP_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_SP)); + break; + case E_PC_REGNUM: + regcache_raw_supply (regcache, E_PC_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_PC)); + break; + case E_MDR_REGNUM: + regcache_raw_supply (regcache, E_MDR_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MDR)); + break; + case E_PSW_REGNUM: + regcache_raw_supply (regcache, E_PSW_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_EPSW)); + break; + case E_LIR_REGNUM: + regcache_raw_supply (regcache, E_LIR_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_LIR)); + break; + case E_LAR_REGNUM: + regcache_raw_supply (regcache, E_LAR_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_LAR)); + break; + case E_MDRQ_REGNUM: + regcache_raw_supply (regcache, E_MDRQ_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MDRQ)); + break; + case E_E0_REGNUM: + regcache_raw_supply (regcache, E_E0_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E0)); + break; + case E_E1_REGNUM: + regcache_raw_supply (regcache, E_E1_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E1)); + break; + case E_E2_REGNUM: + regcache_raw_supply (regcache, E_E2_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E2)); + break; + case E_E3_REGNUM: + regcache_raw_supply (regcache, E_E3_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E3)); + break; + case E_E4_REGNUM: + regcache_raw_supply (regcache, E_E4_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E4)); + break; + case E_E5_REGNUM: + regcache_raw_supply (regcache, E_E5_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E5)); + break; + case E_E6_REGNUM: + regcache_raw_supply (regcache, E_E6_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E6)); + break; + case E_E7_REGNUM: + regcache_raw_supply (regcache, E_E7_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E7)); + break; + + /* ssp, msp, and usp are inaccessible. */ + case E_E8_REGNUM: + memset (zerobuf, 0, MAX_REGISTER_SIZE); + regcache_raw_supply (regcache, E_E8_REGNUM, zerobuf); + break; + case E_E9_REGNUM: + memset (zerobuf, 0, MAX_REGISTER_SIZE); + regcache_raw_supply (regcache, E_E9_REGNUM, zerobuf); + break; + case E_E10_REGNUM: + memset (zerobuf, 0, MAX_REGISTER_SIZE); + regcache_raw_supply (regcache, E_E10_REGNUM, zerobuf); + + break; + case E_MCRH_REGNUM: + regcache_raw_supply (regcache, E_MCRH_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MCRH)); + break; + case E_MCRL_REGNUM: + regcache_raw_supply (regcache, E_MCRL_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MCRL)); + break; + case E_MCVF_REGNUM: + regcache_raw_supply (regcache, E_MCVF_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MCVF)); + break; + case E_FPCR_REGNUM: + /* FPCR is numbered among the GP regs, but handled as an FP reg. + Do nothing. */ + break; + case E_FPCR_REGNUM + 1: + /* The two unused registers beyond fpcr are inaccessible. */ + memset (zerobuf, 0, MAX_REGISTER_SIZE); + regcache_raw_supply (regcache, E_FPCR_REGNUM + 1, zerobuf); + break; + case E_FPCR_REGNUM + 2: + memset (zerobuf, 0, MAX_REGISTER_SIZE); + regcache_raw_supply (regcache, E_FPCR_REGNUM + 2, zerobuf); + break; + default: /* An error, obviously, but should we error out? */ + break; + case -1: + for (i = 0; i < ELF_NGREG; i++) + am33_supply_gregset_method (regset, regcache, i, gregs, len); + break; + } + return; + } + + /* Copy fp register value of REGNUM from regset to regcache. + If REGNUM is -1, do this for all fp registers in regset. */ + + static void + am33_supply_fpregset_method (const struct regset *regset, + struct regcache *regcache, + int regnum, const void *fpregs, size_t len) + { + elf_fpregset_t *fpregset = fpregs; + int i; + + gdb_assert (len == sizeof (elf_fpregset_t)); + + if (regnum == -1) + { + for (i = 0; i < ELF_NFPREG; i++) + am33_supply_fpregset_method (regset, regcache, i, fpregs, len); + am33_supply_fpregset_method (regset, regcache, + E_FPCR_REGNUM, fpregs, len); + } + else if (regnum == E_FPCR_REGNUM) + regcache_raw_supply (current_regcache, E_FPCR_REGNUM, + (void *) &fpregset->fpcr); + else if (i >= 0 && i < ELF_NFPREG) + regcache_raw_supply (current_regcache, E_FS0_REGNUM + i, + (void *) &fpregset->fpregs[i]); + /* else error? */ + + return; + } + + /* Copy register values from regcache to regset. */ + + static void + am33_collect_gregset_method (const struct regset *regset, + const struct regcache *regcache, + int regnum, void *gregs, size_t len) + { + elf_gregset_t *regp = gregs; + int i; + + gdb_assert (len == sizeof (elf_gregset_t)); + + switch (regnum) { + case E_D0_REGNUM: + regcache_raw_collect (regcache, E_D0_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_D0)); + break; + case E_D1_REGNUM: + regcache_raw_collect (regcache, E_D1_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_D1)); + break; + case E_D2_REGNUM: + regcache_raw_collect (regcache, E_D2_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_D2)); + break; + case E_D3_REGNUM: + regcache_raw_collect (regcache, E_D3_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_D3)); + break; + case E_A0_REGNUM: + regcache_raw_collect (regcache, E_A0_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_A0)); + break; + case E_A1_REGNUM: + regcache_raw_collect (regcache, E_A1_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_A1)); + break; + case E_A2_REGNUM: + regcache_raw_collect (regcache, E_A2_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_A2)); + break; + case E_A3_REGNUM: + regcache_raw_collect (regcache, E_A3_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_A3)); + break; + case E_SP_REGNUM: + regcache_raw_collect (regcache, E_SP_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_SP)); + break; + case E_PC_REGNUM: + regcache_raw_collect (regcache, E_PC_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_PC)); + break; + case E_MDR_REGNUM: + regcache_raw_collect (regcache, E_MDR_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MDR)); + break; + case E_PSW_REGNUM: + regcache_raw_collect (regcache, E_PSW_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_EPSW)); + break; + case E_LIR_REGNUM: + regcache_raw_collect (regcache, E_LIR_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_LIR)); + break; + case E_LAR_REGNUM: + regcache_raw_collect (regcache, E_LAR_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_LAR)); + break; + case E_MDRQ_REGNUM: + regcache_raw_collect (regcache, E_MDRQ_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MDRQ)); + break; + case E_E0_REGNUM: + regcache_raw_collect (regcache, E_E0_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E0)); + break; + case E_E1_REGNUM: + regcache_raw_collect (regcache, E_E1_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E1)); + break; + case E_E2_REGNUM: + regcache_raw_collect (regcache, E_E2_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E2)); + break; + case E_E3_REGNUM: + regcache_raw_collect (regcache, E_E3_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E3)); + break; + case E_E4_REGNUM: + regcache_raw_collect (regcache, E_E4_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E4)); + break; + case E_E5_REGNUM: + regcache_raw_collect (regcache, E_E5_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E5)); + break; + case E_E6_REGNUM: + regcache_raw_collect (regcache, E_E6_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E6)); + break; + case E_E7_REGNUM: + regcache_raw_collect (regcache, E_E7_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_E7)); + break; + + /* ssp, msp, and usp are inaccessible. */ + case E_E8_REGNUM: + /* The gregset struct has noplace to put this: do nothing. */ + break; + case E_E9_REGNUM: + /* The gregset struct has noplace to put this: do nothing. */ + break; + case E_E10_REGNUM: + /* The gregset struct has noplace to put this: do nothing. */ + break; + case E_MCRH_REGNUM: + regcache_raw_collect (regcache, E_MCRH_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MCRH)); + break; + case E_MCRL_REGNUM: + regcache_raw_collect (regcache, E_MCRL_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MCRL)); + break; + case E_MCVF_REGNUM: + regcache_raw_collect (regcache, E_MCVF_REGNUM, + (void *) (regp + ELF_GREGSET_T_REG_INDEX_MCVF)); + break; + case E_FPCR_REGNUM: + /* FPCR is numbered among the GP regs, but handled as an FP reg. + Do nothing. */ + break; + case E_FPCR_REGNUM + 1: + /* The gregset struct has noplace to put this: do nothing. */ + break; + case E_FPCR_REGNUM + 2: + /* The gregset struct has noplace to put this: do nothing. */ + break; + default: /* An error, obviously, but should we error out? */ + break; + case -1: + for (i = 0; i < ELF_NGREG; i++) + am33_collect_gregset_method (regset, regcache, i, gregs, len); + break; + } + return; + } + + /* Copy fp register values from regcache to regset. */ + + static void + am33_collect_fpregset_method (const struct regset *regset, + const struct regcache *regcache, + int regnum, void *fpregs, size_t len) + { + elf_fpregset_t *fpregset = fpregs; + int i; + + gdb_assert (len == sizeof (elf_fpregset_t)); + + if (regnum == -1) + { + for (i = 0; i < ELF_NFPREG; i++) + am33_collect_fpregset_method (regset, regcache, i, fpregs, len); + am33_collect_fpregset_method (regset, regcache, + E_FPCR_REGNUM, fpregs, len); + } + else if (regnum == E_FPCR_REGNUM) + regcache_raw_collect (current_regcache, E_FPCR_REGNUM, + (void *) &fpregset->fpcr); + else if (i >= 0 && i < ELF_NFPREG) + regcache_raw_collect (current_regcache, E_FS0_REGNUM + i, + (void *) &fpregset->fpregs[i]); + /* else error? */ + + return; + } + + /* Create a struct regset from a corefile register section. */ + + const struct regset * + am33_regset_from_core_section (struct gdbarch *gdbarch, + const char *sect_name, + size_t sect_size) + { + /* We will call regset_alloc, and pass the names of the supply and + collect methods. */ + + if (sect_size == sizeof (elf_fpregset_t)) + return regset_alloc (gdbarch, + am33_supply_fpregset_method, + am33_collect_fpregset_method); + else + return regset_alloc (gdbarch, + am33_supply_gregset_method, + am33_collect_gregset_method); + } + + /* AM33 Linux osabi has been recognized. + Now's our chance to register our corefile handling. */ + + static void + am33_linux_init_osabi (struct gdbarch_info gdbinfo, struct gdbarch *gdbarch) + { + set_gdbarch_regset_from_core_section (gdbarch, + am33_regset_from_core_section); + } + + /* "Sniff" a bfd, claim it if it's ours. + It's ours if it's am33 flavor. */ + + static enum gdb_osabi + am33_linux_elf_osabi_sniffer (bfd *abfd) + { + const struct bfd_arch_info *info = bfd_get_arch_info (abfd); + int eflags = elf_elfheader (abfd) -> e_flags; + /* We'll want to have a look at those, anyway... */ + + if (info->arch == bfd_arch_mn10300) + if (info->mach == bfd_mach_am33 || info->mach == bfd_mach_am33_2) + if (eflags & (E_MN10300_MACH_AM33 | E_MN10300_MACH_AM33_2) + return GDB_OSABI_LINUX; + + return GDB_OSABI_UNKNOWN; + } + + void + _initialize_mn10300_linux_tdep (void) + { + gdbarch_register_osabi (bfd_arch_mn10300, 0, + GDB_OSABI_LINUX, am33_linux_init_osabi); + gdbarch_register_osabi_sniffer (bfd_arch_mn10300, + bfd_target_elf_flavour, + am33_linux_elf_osabi_sniffer); + } + Index: mn10300-tdep.h =================================================================== RCS file: /cvs/src/src/gdb/mn10300-tdep.h,v retrieving revision 1.4 diff -p -r1.4 mn10300-tdep.h *** mn10300-tdep.h 28 Jun 2005 00:17:50 -0000 1.4 --- mn10300-tdep.h 28 Jun 2005 00:39:25 -0000 *************** *** 1,6 **** /* Target-dependent interface for Matsushita MN10300 for GDB, the GNU debugger. ! Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GDB. --- 1,6 ---- /* Target-dependent interface for Matsushita MN10300 for GDB, the GNU debugger. ! Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GDB. *************** enum { *** 44,53 **** E_E5_REGNUM = 20, E_E6_REGNUM = 21, E_E7_REGNUM = 22, E_MCRH_REGNUM = 26, E_MCRL_REGNUM = 27, E_MCVF_REGNUM = 28, ! E_NUM_REGS = 32 }; enum movm_register_bits { --- 44,58 ---- E_E5_REGNUM = 20, E_E6_REGNUM = 21, E_E7_REGNUM = 22, + E_E8_REGNUM = 23, + E_E9_REGNUM = 24, + E_E10_REGNUM = 25, E_MCRH_REGNUM = 26, E_MCRL_REGNUM = 27, E_MCVF_REGNUM = 28, ! E_FPCR_REGNUM = 29, ! E_NUM_REGS = 32, ! E_FS0_REGNUM = 32 }; enum movm_register_bits { *************** struct gdbarch_tdep *** 77,80 **** #define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode) ! --- 82,88 ---- #define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode) ! #include "regset.h" /* struct regset */ ! extern const struct regset *am33_regset_from_core_section (struct gdbarch *, ! const char *, ! size_t); --------------050707080202000006060206--