From ae1b99e42dbce238cd7eb5efd38672b8306f1148 Mon Sep 17 00:00:00 2001 From: Jeff Law Date: Thu, 3 Oct 1996 16:42:22 +0000 Subject: Grrr. The mn10200 and mn10300 are _not_ similar enough to easily support with a single generic configuration. So break them up into two different configurations. See the individual ChangeLogs for additional detail. --- ChangeLog | 6 + bfd/.Sanitize | 6 +- bfd/ChangeLog | 10 + bfd/Makefile.in | 12 +- bfd/bfd-in2.h | 3 +- bfd/config.bfd | 8 +- bfd/configure | 3 +- bfd/configure.in | 3 +- bfd/cpu-mn10200.c | 38 ++ bfd/cpu-mn10300.c | 38 ++ bfd/cpu-mn10x00.c | 54 --- bfd/elf32-mn10200.c | 111 ++++++ bfd/elf32-mn10300.c | 111 ++++++ bfd/elf32-mn10x00.c | 111 ------ bfd/targets.c | 6 +- config.sub | 5 +- configure.in | 5 +- gas/config/.Sanitize | 6 +- gas/config/tc-mn10300.c | 884 ++++++++++++++++++++++++++++++++++++++++++++ gas/config/tc-mn10x00.c | 884 -------------------------------------------- gas/config/tc-mn10x00.h | 48 --- gas/configure | 3 +- gas/configure.in | 3 +- gas/testsuite/ChangeLog | 5 +- gas/testsuite/gas/.Sanitize | 3 +- include/ChangeLog | 5 + include/dis-asm.h | 3 +- include/elf/ChangeLog | 4 + include/opcode/.Sanitize | 3 +- include/opcode/ChangeLog | 5 + include/opcode/mn10300.h | 75 ++++ include/opcode/mn10x00.h | 75 ---- opcodes/.Sanitize | 4 + opcodes/ChangeLog | 10 + opcodes/mn10200-dis.c | 34 ++ opcodes/mn10200-opc.c | 51 +++ opcodes/mn10300-dis.c | 34 ++ opcodes/mn10300-opc.c | 51 +++ opcodes/mn10x00-dis.c | 34 -- opcodes/mn10x00-opc.c | 51 --- 40 files changed, 1525 insertions(+), 1280 deletions(-) create mode 100644 bfd/cpu-mn10200.c create mode 100644 bfd/cpu-mn10300.c delete mode 100755 bfd/cpu-mn10x00.c create mode 100644 bfd/elf32-mn10200.c create mode 100644 bfd/elf32-mn10300.c delete mode 100644 bfd/elf32-mn10x00.c create mode 100644 gas/config/tc-mn10300.c delete mode 100644 gas/config/tc-mn10x00.c delete mode 100644 gas/config/tc-mn10x00.h create mode 100644 include/opcode/mn10300.h delete mode 100644 include/opcode/mn10x00.h create mode 100644 opcodes/mn10200-dis.c create mode 100644 opcodes/mn10200-opc.c create mode 100644 opcodes/mn10300-dis.c create mode 100644 opcodes/mn10300-opc.c delete mode 100755 opcodes/mn10x00-dis.c delete mode 100644 opcodes/mn10x00-opc.c diff --git a/ChangeLog b/ChangeLog index fdda615..c8eb6a9 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +Thu Oct 3 09:28:25 1996 Jeffrey A Law (law@cygnus.com) + + * configure.in: Break mn10x00 support into separate + mn10200 and mn10300 configurations. + * config.sub: Likewise. + Wed Oct 2 22:27:52 1996 Jeffrey A Law (law@cygnus.com) * configure.in: Add lots of stuff to noconfigdirs for diff --git a/bfd/.Sanitize b/bfd/.Sanitize index 4186890..14662f1 100644 --- a/bfd/.Sanitize +++ b/bfd/.Sanitize @@ -137,7 +137,8 @@ cpu-i960.c cpu-m68k.c cpu-m88k.c cpu-mips.c -cpu-mn10x00.c +cpu-mn10200.c +cpu-mn10300.c cpu-ns32k.c cpu-powerpc.c cpu-rs6000.c @@ -163,7 +164,8 @@ elf32-i860.c elf32-m68k.c elf32-m88k.c elf32-mips.c -elf32-mn10x00.c +elf32-mn10200.c +elf32-mn10300.c elf32-ppc.c elf32-sh.c elf32-sparc.c diff --git a/bfd/ChangeLog b/bfd/ChangeLog index ce0335c..6b76ef4 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,13 @@ +Thu Oct 3 09:29:09 1996 Jeffrey A Law (law@cygnus.com) + + * cpu-mn10x00.c, elf32-mn10x00: Removed. + * cpu-mn10200.c, cpu-mn10300.c: New files. + * elf32-mn10200.c, elf32-mn10300.c: New files. + * Makefile.in: Break mn10x00 support into two separate + configurations, mn10200 and mn10300. + * archures.c, config.bfd, configure.in, elf.c, targets.c: Likewise. + * bfd-in2.h, configure: Rebuilt. + Thu Oct 3 15:38:19 1996 Jason Molenda (crash@godzilla.cygnus.co.jp) * Makefile.in (do_clean): Move config.log to do_distclean. diff --git a/bfd/Makefile.in b/bfd/Makefile.in index 4d4b96d..5cbc436 100644 --- a/bfd/Makefile.in +++ b/bfd/Makefile.in @@ -131,7 +131,8 @@ ALL_MACHINES = \ cpu-m68k.o \ cpu-m88k.o \ cpu-mips.o \ - cpu-mn10x00.o \ + cpu-mn10200.o \ + cpu-mn10300.o \ cpu-ns32k.o \ cpu-powerpc.o \ cpu-rs6000.o \ @@ -219,7 +220,8 @@ BFD32_BACKENDS = \ elf32-m68k.o \ elf32-m88k.o \ elf32-mips.o \ - elf32-mn10x00.o \ + elf32-mn10200.o \ + elf32-mn10300.o \ elf32-ppc.o \ elf32-sh.o \ elf32-sparc.o \ @@ -827,7 +829,11 @@ elf32-m32r.o: elf32-m32r.c elf-bfd.h $(INCDIR)/elf/common.h \ elf32-target.h end-sanitize-m32r: -elf32-mn10x00.o: elf32-mn10x00.c elf-bfd.h $(INCDIR)/elf/common.h \ +elf32-mn10200.o: elf32-mn10200.c elf-bfd.h $(INCDIR)/elf/common.h \ + $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h \ + elf32-target.h + +elf32-mn10300.o: elf32-mn10300.c elf-bfd.h $(INCDIR)/elf/common.h \ $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h \ elf32-target.h diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h index 67dbcb9..252931d 100644 --- a/bfd/bfd-in2.h +++ b/bfd/bfd-in2.h @@ -1229,7 +1229,8 @@ enum bfd_architecture /* start-sanitize-m32r */ bfd_arch_m32r, /* Mitsubishi M32R */ /* end-sanitize-m32r */ - bfd_arch_mn10x00, /* Matsushita MN10x00 */ + bfd_arch_mn10200, /* Matsushita MN10200 */ + bfd_arch_mn10300, /* Matsushita MN10300 */ bfd_arch_last }; diff --git a/bfd/config.bfd b/bfd/config.bfd index a780aca..7c9b4ee 100755 --- a/bfd/config.bfd +++ b/bfd/config.bfd @@ -393,8 +393,12 @@ case "${targ}" in targ_selvecs="bfd_elf32_littlemips_vec bfd_elf64_bigmips_vec bfd_elf64_littlemips_vec" ;; - mn10x00-*-*) - targ_defvec=bfd_elf32_mn10x00_vec + mn10200-*-*) + targ_defvec=bfd_elf32_mn10200_vec + ;; + + mn10300-*-*) + targ_defvec=bfd_elf32_mn10300_vec ;; ns32k-pc532-mach* | ns32k-pc532-ux*) diff --git a/bfd/configure b/bfd/configure index 51a0fc8..d655f1a 100755 --- a/bfd/configure +++ b/bfd/configure @@ -1928,7 +1928,8 @@ do # end-sanitize-m32r bfd_elf32_m68k_vec) tb="$tb elf32-m68k.o elf32.o $elf" ;; bfd_elf32_m88k_vec) tb="$tb elf32-m88k.o elf32.o $elf" ;; - bfd_elf32_mn10x00_vec) tb="$tb elf32-mn10x00.o elf32.o $elf" ;; + bfd_elf32_mn10200_vec) tb="$tb elf32-mn10200.o elf32.o $elf" ;; + bfd_elf32_mn10300_vec) tb="$tb elf32-mn10300.o elf32.o $elf" ;; bfd_elf32_powerpc_vec) tb="$tb elf32-ppc.o elf32.o $elf" ;; bfd_elf32_powerpcle_vec) tb="$tb elf32-ppc.o elf32.o $elf" ;; bfd_elf32_sh_vec) tb="$tb elf32-sh.o elf32.o $elf coff-sh.o" ;; diff --git a/bfd/configure.in b/bfd/configure.in index 8b88d41..467db82 100644 --- a/bfd/configure.in +++ b/bfd/configure.in @@ -456,7 +456,8 @@ do # end-sanitize-m32r bfd_elf32_m68k_vec) tb="$tb elf32-m68k.o elf32.o $elf" ;; bfd_elf32_m88k_vec) tb="$tb elf32-m88k.o elf32.o $elf" ;; - bfd_elf32_mn10x00_vec) tb="$tb elf32-mn10x00.o elf32.o $elf" ;; + bfd_elf32_mn10200_vec) tb="$tb elf32-mn10200.o elf32.o $elf" ;; + bfd_elf32_mn10300_vec) tb="$tb elf32-mn10300.o elf32.o $elf" ;; bfd_elf32_powerpc_vec) tb="$tb elf32-ppc.o elf32.o $elf" ;; bfd_elf32_powerpcle_vec) tb="$tb elf32-ppc.o elf32.o $elf" ;; bfd_elf32_sh_vec) tb="$tb elf32-sh.o elf32.o $elf coff-sh.o" ;; diff --git a/bfd/cpu-mn10200.c b/bfd/cpu-mn10200.c new file mode 100644 index 0000000..2a0a988 --- /dev/null +++ b/bfd/cpu-mn10200.c @@ -0,0 +1,38 @@ +/* BFD support for the Matsushita 10200 processor + Copyright 1996 Free Software Foundation, Inc. + +This file is part of BFD, the Binary File Descriptor library. + +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 "bfd.h" +#include "sysdep.h" +#include "libbfd.h" + +const bfd_arch_info_type bfd_mn10200_arch = + { + 16, /* 16 bits in a word */ + 24, /* 16 bits in an address */ + 8, /* 8 bits in a byte */ + bfd_arch_mn10200, + 200, + "mn10200", + "mn10200", + 2, + true, /* the one and only */ + bfd_default_compatible, + bfd_default_scan , + 0, + }; diff --git a/bfd/cpu-mn10300.c b/bfd/cpu-mn10300.c new file mode 100644 index 0000000..fc6108d --- /dev/null +++ b/bfd/cpu-mn10300.c @@ -0,0 +1,38 @@ +/* BFD support for the Matsushita 10300 processor + Copyright 1996 Free Software Foundation, Inc. + +This file is part of BFD, the Binary File Descriptor library. + +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 "bfd.h" +#include "sysdep.h" +#include "libbfd.h" + +const bfd_arch_info_type bfd_mn10300_arch = + { + 32, /* 16 bits in a word */ + 32, /* 16 bits in an address */ + 8, /* 8 bits in a byte */ + bfd_arch_mn10300, + 300, + "mn10300", + "mn10300", + 2, + true, /* the one and only */ + bfd_default_compatible, + bfd_default_scan , + 0, + }; diff --git a/bfd/cpu-mn10x00.c b/bfd/cpu-mn10x00.c deleted file mode 100755 index b8f1c56..0000000 --- a/bfd/cpu-mn10x00.c +++ /dev/null @@ -1,54 +0,0 @@ -/* BFD support for the Matsushita 10200 and 10300 processors - Copyright 1996 Free Software Foundation, Inc. - -This file is part of BFD, the Binary File Descriptor library. - -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 "bfd.h" -#include "sysdep.h" -#include "libbfd.h" - -const bfd_arch_info_type bfd_mn10200_arch = - { - 16, /* 16 bits in a word */ - 24, /* 16 bits in an address */ - 8, /* 8 bits in a byte */ - bfd_arch_mn10x00, - 200, - "mn10x00", - "mn10200", - 2, - true, /* the one and only */ - bfd_default_compatible, - bfd_default_scan , - 0, - }; - -const bfd_arch_info_type bfd_mn10x00_arch = - { - 16, - 24, - 8, - bfd_arch_mn10x00, - 300, - "mn10x00", - "mn10300", - 2, - false, - bfd_default_compatible, - bfd_default_scan, - &bfd_mn10200_arch - }; diff --git a/bfd/elf32-mn10200.c b/bfd/elf32-mn10200.c new file mode 100644 index 0000000..88c3cbe --- /dev/null +++ b/bfd/elf32-mn10200.c @@ -0,0 +1,111 @@ +/* Matsushita 10200 specific support for 32-bit ELF + Copyright (C) 1996 Free Software Foundation, Inc. + +This file is part of BFD, the Binary File Descriptor library. + +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 "bfd.h" +#include "sysdep.h" +#include "libbfd.h" +#include "elf-bfd.h" + +static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup + PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); +static void mn10200_info_to_howto_rel + PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *)); + +/* Try to minimize the amount of space occupied by relocation tables + on the ROM (not that the ROM won't be swamped by other ELF overhead). */ +#define USE_REL + +enum reloc_type +{ + R_MN10200_NONE = 0, + R_MN10200_MAX +}; + +static reloc_howto_type elf_mn10200_howto_table[] = +{ + /* */ + HOWTO (R_MN10200_NONE, + 0, + 2, + 16, + false, + 0, + complain_overflow_bitfield, + bfd_elf_generic_reloc, + "R_MN10200_NONE", + false, + 0, + 0, + false), +}; + +struct mn10200_reloc_map +{ + unsigned char bfd_reloc_val; + unsigned char elf_reloc_val; +}; + +static const struct mn10200_reloc_map mn10200_reloc_map[] = +{ + { BFD_RELOC_NONE, R_MN10200_NONE, }, +}; + +static reloc_howto_type * +bfd_elf32_bfd_reloc_type_lookup (abfd, code) + bfd *abfd; + bfd_reloc_code_real_type code; +{ + unsigned int i; + + for (i = 0; + i < sizeof (mn10200_reloc_map) / sizeof (struct mn10200_reloc_map); + i++) + { + if (mn10200_reloc_map[i].bfd_reloc_val == code) + return &elf_mn10200_howto_table[mn10200_reloc_map[i].elf_reloc_val]; + } + + return NULL; +} + +/* Set the howto pointer for an V850 ELF reloc. */ + +static void +mn10200_info_to_howto_rel (abfd, cache_ptr, dst) + bfd *abfd; + arelent *cache_ptr; + Elf32_Internal_Rel *dst; +{ + unsigned int r_type; + + r_type = ELF32_R_TYPE (dst->r_info); + BFD_ASSERT (r_type < (unsigned int) R_MN10200_MAX); + cache_ptr->howto = &elf_mn10200_howto_table[r_type]; +} + +#define TARGET_LITTLE_SYM bfd_elf32_mn10200_vec +#define TARGET_LITTLE_NAME "elf32-mn10200" +#define ELF_ARCH bfd_arch_mn10200 +#define ELF_MACHINE_CODE EM_CYGNUS_MN10200 +#define ELF_MAXPAGESIZE 0x1000 + +#define elf_info_to_howto 0 +#define elf_info_to_howto_rel mn10200_info_to_howto_rel + +#include "elf32-target.h" diff --git a/bfd/elf32-mn10300.c b/bfd/elf32-mn10300.c new file mode 100644 index 0000000..309fa40 --- /dev/null +++ b/bfd/elf32-mn10300.c @@ -0,0 +1,111 @@ +/* Matsushita 10300 specific support for 32-bit ELF + Copyright (C) 1996 Free Software Foundation, Inc. + +This file is part of BFD, the Binary File Descriptor library. + +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 "bfd.h" +#include "sysdep.h" +#include "libbfd.h" +#include "elf-bfd.h" + +static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup + PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); +static void mn10300_info_to_howto_rel + PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *)); + +/* Try to minimize the amount of space occupied by relocation tables + on the ROM (not that the ROM won't be swamped by other ELF overhead). */ +#define USE_REL + +enum reloc_type +{ + R_MN10300_NONE = 0, + R_MN10300_MAX +}; + +static reloc_howto_type elf_mn10300_howto_table[] = +{ + /* */ + HOWTO (R_MN10300_NONE, + 0, + 2, + 16, + false, + 0, + complain_overflow_bitfield, + bfd_elf_generic_reloc, + "R_MN10300_NONE", + false, + 0, + 0, + false), +}; + +struct mn10300_reloc_map +{ + unsigned char bfd_reloc_val; + unsigned char elf_reloc_val; +}; + +static const struct mn10300_reloc_map mn10300_reloc_map[] = +{ + { BFD_RELOC_NONE, R_MN10300_NONE, }, +}; + +static reloc_howto_type * +bfd_elf32_bfd_reloc_type_lookup (abfd, code) + bfd *abfd; + bfd_reloc_code_real_type code; +{ + unsigned int i; + + for (i = 0; + i < sizeof (mn10300_reloc_map) / sizeof (struct mn10300_reloc_map); + i++) + { + if (mn10300_reloc_map[i].bfd_reloc_val == code) + return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val]; + } + + return NULL; +} + +/* Set the howto pointer for an V850 ELF reloc. */ + +static void +mn10300_info_to_howto_rel (abfd, cache_ptr, dst) + bfd *abfd; + arelent *cache_ptr; + Elf32_Internal_Rel *dst; +{ + unsigned int r_type; + + r_type = ELF32_R_TYPE (dst->r_info); + BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX); + cache_ptr->howto = &elf_mn10300_howto_table[r_type]; +} + +#define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec +#define TARGET_LITTLE_NAME "elf32-mn10300" +#define ELF_ARCH bfd_arch_mn10300 +#define ELF_MACHINE_CODE EM_CYGNUS_MN10300 +#define ELF_MAXPAGESIZE 0x1000 + +#define elf_info_to_howto 0 +#define elf_info_to_howto_rel mn10300_info_to_howto_rel + +#include "elf32-target.h" diff --git a/bfd/elf32-mn10x00.c b/bfd/elf32-mn10x00.c deleted file mode 100644 index 15fab94..0000000 --- a/bfd/elf32-mn10x00.c +++ /dev/null @@ -1,111 +0,0 @@ -/* Matsushita 10200 and 10300 specific support for 32-bit ELF - Copyright (C) 1994, 1995 Free Software Foundation, Inc. - -This file is part of BFD, the Binary File Descriptor library. - -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 "bfd.h" -#include "sysdep.h" -#include "libbfd.h" -#include "elf-bfd.h" - -static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup - PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); -static void mn10x00_info_to_howto_rel - PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *)); - -/* Try to minimize the amount of space occupied by relocation tables - on the ROM (not that the ROM won't be swamped by other ELF overhead). */ -#define USE_REL - -enum reloc_type -{ - R_MN10x00_NONE = 0, - R_MN10x00_MAX -}; - -static reloc_howto_type elf_mn10x00_howto_table[] = -{ - /* */ - HOWTO (R_MN10x00_NONE, - 0, - 2, - 16, - false, - 0, - complain_overflow_bitfield, - bfd_elf_generic_reloc, - "R_MN10x00_NONE", - false, - 0, - 0, - false), -}; - -struct mn10x00_reloc_map -{ - unsigned char bfd_reloc_val; - unsigned char elf_reloc_val; -}; - -static const struct mn10x00_reloc_map mn10x00_reloc_map[] = -{ - { BFD_RELOC_NONE, R_MN10x00_NONE, }, -}; - -static reloc_howto_type * -bfd_elf32_bfd_reloc_type_lookup (abfd, code) - bfd *abfd; - bfd_reloc_code_real_type code; -{ - unsigned int i; - - for (i = 0; - i < sizeof (mn10x00_reloc_map) / sizeof (struct mn10x00_reloc_map); - i++) - { - if (mn10x00_reloc_map[i].bfd_reloc_val == code) - return &elf_mn10x00_howto_table[mn10x00_reloc_map[i].elf_reloc_val]; - } - - return NULL; -} - -/* Set the howto pointer for an V850 ELF reloc. */ - -static void -mn10x00_info_to_howto_rel (abfd, cache_ptr, dst) - bfd *abfd; - arelent *cache_ptr; - Elf32_Internal_Rel *dst; -{ - unsigned int r_type; - - r_type = ELF32_R_TYPE (dst->r_info); - BFD_ASSERT (r_type < (unsigned int) R_MN10x00_MAX); - cache_ptr->howto = &elf_mn10x00_howto_table[r_type]; -} - -#define TARGET_LITTLE_SYM bfd_elf32_mn10x00_vec -#define TARGET_LITTLE_NAME "elf32-mn10x00" -#define ELF_ARCH bfd_arch_mn10x00 -#define ELF_MACHINE_CODE EM_CYGNUS_MN10x00 -#define ELF_MAXPAGESIZE 0x1000 - -#define elf_info_to_howto 0 -#define elf_info_to_howto_rel mn10x00_info_to_howto_rel - -#include "elf32-target.h" diff --git a/bfd/targets.c b/bfd/targets.c index 5e7a470..964e656 100644 --- a/bfd/targets.c +++ b/bfd/targets.c @@ -503,7 +503,8 @@ extern const bfd_target bfd_elf32_m32r_vec; /* end-sanitize-m32r */ extern const bfd_target bfd_elf32_m68k_vec; extern const bfd_target bfd_elf32_m88k_vec; -extern const bfd_target bfd_elf32_mn10x00_vec; +extern const bfd_target bfd_elf32_mn10200_vec; +extern const bfd_target bfd_elf32_mn10300_vec; extern const bfd_target bfd_elf32_powerpc_vec; extern const bfd_target bfd_elf32_powerpcle_vec; extern const bfd_target bfd_elf32_sh_vec; @@ -664,7 +665,8 @@ const bfd_target * const bfd_target_vector[] = { /* start-sanitize-m32r */ &bfd_elf32_m32r_vec, /* end-sanitize-m32r */ - &bfd_elf32_mn10x00_vec, + &bfd_elf32_mn10200_vec, + &bfd_elf32_mn10300_vec, &bfd_elf32_m68k_vec, &bfd_elf32_m88k_vec, &bfd_elf32_sparc_vec, diff --git a/config.sub b/config.sub index 242215a..2762ff2 100755 --- a/config.sub +++ b/config.sub @@ -186,7 +186,10 @@ case $basic_machine in basic_machine=$basic_machine-unknown ;; # end-sanitize-m32r - mn10x00) + mn10200) + basic_machine=$basic_machine-unknown + ;; + mn10300) basic_machine=$basic_machine-unknown ;; # Object if more than one company name word. diff --git a/configure.in b/configure.in index 9c0a47f..fc53180 100644 --- a/configure.in +++ b/configure.in @@ -490,7 +490,10 @@ case "${target}" in noconfigdirs="$noconfigdirs target-libgloss libio libstdc++ libg++ gdb" ;; # end-sanitize-m32r - mn10x00-*-*) + mn10200-*-*) + noconfigdirs="$noconfigdirs ld gcc gdb target-libiberty target-libgloss target-newlib target-libio target-librx target-libstdc++ target-libg++" + ;; + mn10300-*-*) noconfigdirs="$noconfigdirs ld gcc gdb target-libiberty target-libgloss target-newlib target-libio target-librx target-libstdc++ target-libg++" ;; powerpc-*-aix*) diff --git a/gas/config/.Sanitize b/gas/config/.Sanitize index da1092a..97641cb 100644 --- a/gas/config/.Sanitize +++ b/gas/config/.Sanitize @@ -120,8 +120,10 @@ tc-m88k.c tc-m88k.h tc-mips.c tc-mips.h -tc-mn10x00.c -tc-mn10x00.h +tc-mn10200.c +tc-mn10200.h +tc-mn10300.c +tc-mn10300.h tc-ns32k.c tc-ns32k.h tc-ppc.c diff --git a/gas/config/tc-mn10300.c b/gas/config/tc-mn10300.c new file mode 100644 index 0000000..c928a86 --- /dev/null +++ b/gas/config/tc-mn10300.c @@ -0,0 +1,884 @@ +/* tc-mn10300.c -- Assembler code for the Matsushita 10300 + + Copyright (C) 1996 Free Software Foundation. + + This file is part of GAS, the GNU Assembler. + + GAS 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, or (at your option) + any later version. + + GAS 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 GAS; see the file COPYING. If not, write to + the Free Software Foundation, 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#include +#include +#include "as.h" +#include "subsegs.h" +#include "opcode/mn10300.h" + +/* Structure to hold information about predefined registers. */ +struct reg_name +{ + const char *name; + int value; +}; + +/* Generic assembler global variables which must be defined by all targets. */ + +/* Characters which always start a comment. */ +const char comment_chars[] = "#"; + +/* Characters which start a comment at the beginning of a line. */ +const char line_comment_chars[] = ";#"; + +/* Characters which may be used to separate multiple commands on a + single line. */ +const char line_separator_chars[] = ";"; + +/* Characters which are used to indicate an exponent in a floating + point number. */ +const char EXP_CHARS[] = "eE"; + +/* Characters which mean that a number is a floating point constant, + as in 0d1.0. */ +const char FLT_CHARS[] = "dD"; + + +/* local functions */ +static unsigned long mn10300 + PARAMS ((unsigned long insn, const struct mn10300_operand *operand, + offsetT val, char *file, unsigned int line)); +static int reg_name_search PARAMS ((const struct reg_name *, int, const char *)); +static boolean register_name PARAMS ((expressionS *expressionP)); +static boolean system_register_name PARAMS ((expressionS *expressionP)); +static boolean cc_name PARAMS ((expressionS *expressionP)); +static bfd_reloc_code_real_type mn10300_reloc_prefix PARAMS ((void)); + + +/* fixups */ +#define MAX_INSN_FIXUPS (5) +struct mn10300_fixup +{ + expressionS exp; + int opindex; + bfd_reloc_code_real_type reloc; +}; +struct mn10300_fixup fixups[MAX_INSN_FIXUPS]; +static int fc; + +const char *md_shortopts = ""; +struct option md_longopts[] = { + {NULL, no_argument, NULL, 0} +}; +size_t md_longopts_size = sizeof(md_longopts); + +/* The target specific pseudo-ops which we support. */ +const pseudo_typeS md_pseudo_table[] = +{ + { NULL, NULL, 0 } +}; + +/* Opcode hash table. */ +static struct hash_control *mn10300_hash; + +/* This table is sorted. Suitable for searching by a binary search. */ +static const struct reg_name pre_defined_registers[] = +{ + { "ep", 30 }, /* ep - element ptr */ + { "gp", 4 }, /* gp - global ptr */ + { "lp", 31 }, /* lp - link ptr */ + { "r0", 0 }, + { "r1", 1 }, + { "r10", 10 }, + { "r11", 11 }, + { "r12", 12 }, + { "r13", 13 }, + { "r14", 14 }, + { "r15", 15 }, + { "r16", 16 }, + { "r17", 17 }, + { "r18", 18 }, + { "r19", 19 }, + { "r2", 2 }, + { "r20", 20 }, + { "r21", 21 }, + { "r22", 22 }, + { "r23", 23 }, + { "r24", 24 }, + { "r25", 25 }, + { "r26", 26 }, + { "r27", 27 }, + { "r28", 28 }, + { "r29", 29 }, + { "r3", 3 }, + { "r30", 30 }, + { "r31", 31 }, + { "r4", 4 }, + { "r5", 5 }, + { "r6", 6 }, + { "r7", 7 }, + { "r8", 8 }, + { "r9", 9 }, + { "sp", 3 }, /* sp - stack ptr */ + { "tp", 5 }, /* tp - text ptr */ + { "zero", 0 }, +}; +#define REG_NAME_CNT (sizeof(pre_defined_registers) / sizeof(struct reg_name)) + + +static const struct reg_name system_registers[] = +{ + { "eipc", 0 }, + { "eipsw", 1 }, + { "fepc", 2 }, + { "fepsw", 3 }, + { "ecr", 4 }, + { "psw", 5 }, +}; +#define SYSREG_NAME_CNT (sizeof(system_registers) / sizeof(struct reg_name)) + +static const struct reg_name cc_names[] = +{ + { "c", 0x1 }, + { "ge", 0xe }, + { "gt", 0xf }, + { "h", 0xb }, + { "l", 0x1 }, + { "le", 0x7 }, + { "lt", 0x6 }, + { "n", 0x4 }, + { "nc", 0x9 }, + { "nh", 0x3 }, + { "nl", 0x9 }, + { "ns", 0xc }, + { "nv", 0x8 }, + { "nz", 0xa }, + { "p", 0xc }, + { "s", 0x4 }, + { "sa", 0xd }, + { "t", 0x5 }, + { "v", 0x0 }, + { "z", 0x2 }, +}; +#define CC_NAME_CNT (sizeof(cc_names) / sizeof(struct reg_name)) + +/* reg_name_search does a binary search of the given register table + to see if "name" is a valid regiter name. Returns the register + number from the array on success, or -1 on failure. */ + +static int +reg_name_search (regs, regcount, name) + const struct reg_name *regs; + int regcount; + const char *name; +{ + int middle, low, high; + int cmp; + + low = 0; + high = regcount - 1; + + do + { + middle = (low + high) / 2; + cmp = strcasecmp (name, regs[middle].name); + if (cmp < 0) + high = middle - 1; + else if (cmp > 0) + low = middle + 1; + else + return regs[middle].value; + } + while (low <= high); + return -1; +} + + +/* Summary of register_name(). + * + * in: Input_line_pointer points to 1st char of operand. + * + * out: A expressionS. + * The operand may have been a register: in this case, X_op == O_register, + * X_add_number is set to the register number, and truth is returned. + * Input_line_pointer->(next non-blank) char after operand, or is in + * its original state. + */ +static boolean +register_name (expressionP) + expressionS *expressionP; +{ + int reg_number; + char *name; + char *start; + char c; + + /* Find the spelling of the operand */ + start = name = input_line_pointer; + + c = get_symbol_end (); + reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name); + + /* look to see if it's in the register table */ + if (reg_number >= 0) + { + expressionP->X_op = O_register; + expressionP->X_add_number = reg_number; + + /* make the rest nice */ + expressionP->X_add_symbol = NULL; + expressionP->X_op_symbol = NULL; + *input_line_pointer = c; /* put back the delimiting char */ + return true; + } + else + { + /* reset the line as if we had not done anything */ + *input_line_pointer = c; /* put back the delimiting char */ + input_line_pointer = start; /* reset input_line pointer */ + return false; + } +} + +/* Summary of system_register_name(). + * + * in: Input_line_pointer points to 1st char of operand. + * + * out: A expressionS. + * The operand may have been a register: in this case, X_op == O_register, + * X_add_number is set to the register number, and truth is returned. + * Input_line_pointer->(next non-blank) char after operand, or is in + * its original state. + */ +static boolean +system_register_name (expressionP) + expressionS *expressionP; +{ + int reg_number; + char *name; + char *start; + char c; + + /* Find the spelling of the operand */ + start = name = input_line_pointer; + + c = get_symbol_end (); + reg_number = reg_name_search (system_registers, SYSREG_NAME_CNT, name); + + /* look to see if it's in the register table */ + if (reg_number >= 0) + { + expressionP->X_op = O_register; + expressionP->X_add_number = reg_number; + + /* make the rest nice */ + expressionP->X_add_symbol = NULL; + expressionP->X_op_symbol = NULL; + *input_line_pointer = c; /* put back the delimiting char */ + return true; + } + else + { + /* reset the line as if we had not done anything */ + *input_line_pointer = c; /* put back the delimiting char */ + input_line_pointer = start; /* reset input_line pointer */ + return false; + } +} + +/* Summary of cc_name(). + * + * in: Input_line_pointer points to 1st char of operand. + * + * out: A expressionS. + * The operand may have been a register: in this case, X_op == O_register, + * X_add_number is set to the register number, and truth is returned. + * Input_line_pointer->(next non-blank) char after operand, or is in + * its original state. + */ +static boolean +cc_name (expressionP) + expressionS *expressionP; +{ + int reg_number; + char *name; + char *start; + char c; + + /* Find the spelling of the operand */ + start = name = input_line_pointer; + + c = get_symbol_end (); + reg_number = reg_name_search (cc_names, CC_NAME_CNT, name); + + /* look to see if it's in the register table */ + if (reg_number >= 0) + { + expressionP->X_op = O_constant; + expressionP->X_add_number = reg_number; + + /* make the rest nice */ + expressionP->X_add_symbol = NULL; + expressionP->X_op_symbol = NULL; + *input_line_pointer = c; /* put back the delimiting char */ + return true; + } + else + { + /* reset the line as if we had not done anything */ + *input_line_pointer = c; /* put back the delimiting char */ + input_line_pointer = start; /* reset input_line pointer */ + return false; + } +} + +void +md_show_usage (stream) + FILE *stream; +{ + fprintf(stream, "MN10300 options:\n\ +none yet\n"); +} + +int +md_parse_option (c, arg) + int c; + char *arg; +{ + return 0; +} + +symbolS * +md_undefined_symbol (name) + char *name; +{ + return 0; +} + +char * +md_atof (type, litp, sizep) + int type; + char *litp; + int *sizep; +{ + int prec; + LITTLENUM_TYPE words[4]; + char *t; + int i; + + switch (type) + { + case 'f': + prec = 2; + break; + + case 'd': + prec = 4; + break; + + default: + *sizep = 0; + return "bad call to md_atof"; + } + + t = atof_ieee (input_line_pointer, type, words); + if (t) + input_line_pointer = t; + + *sizep = prec * 2; + + for (i = prec - 1; i >= 0; i--) + { + md_number_to_chars (litp, (valueT) words[i], 2); + litp += 2; + } + + return NULL; +} + + +void +md_convert_frag (abfd, sec, fragP) + bfd *abfd; + asection *sec; + fragS *fragP; +{ + /* printf ("call to md_convert_frag \n"); */ + abort (); +} + +valueT +md_section_align (seg, addr) + asection *seg; + valueT addr; +{ + int align = bfd_get_section_alignment (stdoutput, seg); + return ((addr + (1 << align) - 1) & (-1 << align)); +} + +void +md_begin () +{ + char *prev_name = ""; + register const struct mn10300_opcode *op; + + mn10300_hash = hash_new(); + + /* Insert unique names into hash table. The MN10300 instruction set + has many identical opcode names that have different opcodes based + on the operands. This hash table then provides a quick index to + the first opcode with a particular name in the opcode table. */ + + op = mn10300_opcodes; + while (op->name) + { + if (strcmp (prev_name, op->name)) + { + prev_name = (char *) op->name; + hash_insert (mn10300_hash, op->name, (char *) op); + } + op++; + } +} + +static bfd_reloc_code_real_type +mn10300_reloc_prefix() +{ + if (strncmp(input_line_pointer, "hi0(", 4) == 0) + { + input_line_pointer += 4; + return BFD_RELOC_HI16; + } + if (strncmp(input_line_pointer, "hi(", 3) == 0) + { + input_line_pointer += 3; + return BFD_RELOC_HI16_S; + } + if (strncmp (input_line_pointer, "lo(", 3) == 0) + { + input_line_pointer += 3; + return BFD_RELOC_LO16; + } + + /* FIXME: implement sda, tda, zda here */ + + return BFD_RELOC_UNUSED; +} + +void +md_assemble (str) + char *str; +{ + char *s; + struct mn10300_opcode *opcode; + struct mn10300_opcode *next_opcode; + const unsigned char *opindex_ptr; + int next_opindex; + unsigned long insn, size; + char *f; + int i; + int match; + bfd_reloc_code_real_type reloc; + + /* Get the opcode. */ + for (s = str; *s != '\0' && ! isspace (*s); s++) + ; + if (*s != '\0') + *s++ = '\0'; + + /* find the first opcode with the proper name */ + opcode = (struct mn10300_opcode *)hash_find (mn10300_hash, str); + if (opcode == NULL) + { + as_bad ("Unrecognized opcode: `%s'", str); + return; + } + + str = s; + while (isspace (*str)) + ++str; + + input_line_pointer = str; + + for(;;) + { + const char *errmsg = NULL; + + fc = 0; + match = 0; + next_opindex = 0; + insn = opcode->opcode; + for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++) + { + const struct mn10300_operand *operand; + char *hold; + expressionS ex; + + if (next_opindex == 0) + { + operand = &mn10300_operands[*opindex_ptr]; + } + else + { + operand = &mn10300_operands[next_opindex]; + next_opindex = 0; + } + + errmsg = NULL; + + while (*str == ' ' || *str == ',' || *str == '[' || *str == ']') + ++str; + + /* Gather the operand. */ + hold = input_line_pointer; + input_line_pointer = str; + + + /* lo(), hi(), hi0(), etc... */ + if ((reloc = mn10300_reloc_prefix()) != BFD_RELOC_UNUSED) + { + expression(&ex); + + if (*input_line_pointer++ != ')') + { + errmsg = "syntax error: expected `)'"; + goto error; + } + + if (ex.X_op == O_constant) + { + switch (reloc) + { + case BFD_RELOC_LO16: + ex.X_add_number &= 0xffff; + break; + + case BFD_RELOC_HI16: + ex.X_add_number = ((ex.X_add_number >> 16) & 0xffff); + break; + + case BFD_RELOC_HI16_S: + ex.X_add_number = ((ex.X_add_number >> 16) & 0xffff) + + ((ex.X_add_number >> 15) & 1); + break; + + default: + break; + } + + insn = mn10300_insert_operand (insn, operand, ex.X_add_number, + (char *) NULL, 0); + } + else + { + if (fc > MAX_INSN_FIXUPS) + as_fatal ("too many fixups"); + + fixups[fc].exp = ex; + fixups[fc].opindex = *opindex_ptr; + fixups[fc].reloc = reloc; + fc++; + } + } + else + { + switch (ex.X_op) + { + case O_illegal: + errmsg = "illegal operand"; + goto error; + case O_absent: + errmsg = "missing operand"; + goto error; + case O_register: + + insn = mn10300_insert_operand (insn, operand, ex.X_add_number, + (char *) NULL, 0); + break; + + case O_constant: + insn = mn10300_insert_operand (insn, operand, ex.X_add_number, + (char *) NULL, 0); + break; + + default: + /* We need to generate a fixup for this expression. */ + if (fc >= MAX_INSN_FIXUPS) + as_fatal ("too many fixups"); + fixups[fc].exp = ex; + fixups[fc].opindex = *opindex_ptr; + fixups[fc].reloc = BFD_RELOC_UNUSED; + ++fc; + break; + } + + } + + str = input_line_pointer; + input_line_pointer = hold; + + while (*str == ' ' || *str == ',' || *str == '[' || *str == ']') + ++str; + } + match = 1; + + error: + if (match == 0) + { + next_opcode = opcode + 1; + if (next_opcode->opcode != 0 && !strcmp(next_opcode->name, opcode->name)) + { + opcode = next_opcode; + continue; + } + + as_bad ("%s", errmsg); + return; + } + break; + } + + while (isspace (*str)) + ++str; + + if (*str != '\0') + as_bad ("junk at end of line: `%s'", str); + + input_line_pointer = str; + + /* Write out the instruction. + + Four byte insns have an opcode with the two high bits on. */ + if ((insn & 0x0600) == 0x0600) + size = 4; + else + size = 2; + f = frag_more (size); + md_number_to_chars (f, insn, size); + + /* Create any fixups. At this point we do not use a + bfd_reloc_code_real_type, but instead just use the + BFD_RELOC_UNUSED plus the operand index. This lets us easily + handle fixups for any operand type, although that is admittedly + not a very exciting feature. We pick a BFD reloc type in + md_apply_fix. */ + for (i = 0; i < fc; i++) + { + const struct mn10300_operand *operand; + + operand = &mn10300_operands[fixups[i].opindex]; + if (fixups[i].reloc != BFD_RELOC_UNUSED) + { + reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc); + int size; + int offset; + fixS *fixP; + + if (!reloc_howto) + abort(); + + size = bfd_get_reloc_size (reloc_howto); + offset = 4 - size; + + if (size < 1 || size > 4) + abort(); + + fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset, size, + &fixups[i].exp, + reloc_howto->pc_relative, + fixups[i].reloc); + } + else + { + fix_new_exp (frag_now, f - frag_now->fr_literal, 4, + &fixups[i].exp, + 1 /* FIXME: MN10300_OPERAND_RELATIVE ??? */, + ((bfd_reloc_code_real_type) + (fixups[i].opindex + (int) BFD_RELOC_UNUSED))); + } + } +} + + +/* if while processing a fixup, a reloc really needs to be created */ +/* then it is done here */ + +arelent * +tc_gen_reloc (seg, fixp) + asection *seg; + fixS *fixp; +{ + arelent *reloc; + reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent)); + reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym; + reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; + reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type); + if (reloc->howto == (reloc_howto_type *) NULL) + { + as_bad_where (fixp->fx_file, fixp->fx_line, + "reloc %d not supported by object file format", (int)fixp->fx_r_type); + return NULL; + } + reloc->addend = fixp->fx_addnumber; + /* printf("tc_gen_reloc: addr=%x addend=%x\n", reloc->address, reloc->addend); */ + return reloc; +} + +int +md_estimate_size_before_relax (fragp, seg) + fragS *fragp; + asection *seg; +{ + return 0; +} + +long +md_pcrel_from (fixp) + fixS *fixp; +{ + if (fixp->fx_addsy != (symbolS *) NULL && ! S_IS_DEFINED (fixp->fx_addsy)) + { + /* The symbol is undefined. Let the linker figure it out. */ + return 0; + } + return fixp->fx_frag->fr_address + fixp->fx_where; +} + +int +md_apply_fix3 (fixp, valuep, seg) + fixS *fixp; + valueT *valuep; + segT seg; +{ + valueT value; + char *where; + + if (fixp->fx_addsy == (symbolS *) NULL) + { + value = *valuep; + fixp->fx_done = 1; + } + else if (fixp->fx_pcrel) + value = *valuep; + else + { + value = fixp->fx_offset; + if (fixp->fx_subsy != (symbolS *) NULL) + { + if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section) + value -= S_GET_VALUE (fixp->fx_subsy); + else + { + /* We don't actually support subtracting a symbol. */ + as_bad_where (fixp->fx_file, fixp->fx_line, + "expression too complex"); + } + } + } + + /* printf("md_apply_fix: value=0x%x type=%d\n", value, fixp->fx_r_type); */ + + if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED) + { + int opindex; + const struct mn10300_operand *operand; + char *where; + unsigned long insn; + + opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED; + operand = &mn10300_operands[opindex]; + + /* Fetch the instruction, insert the fully resolved operand + value, and stuff the instruction back again. + + Note the instruction has been stored in little endian + format! */ + where = fixp->fx_frag->fr_literal + fixp->fx_where; + + insn = bfd_getl32((unsigned char *) where); + insn = mn10300_insert_operand (insn, operand, (offsetT) value, + fixp->fx_file, fixp->fx_line); + bfd_putl32((bfd_vma) insn, (unsigned char *) where); + + if (fixp->fx_done) + { + /* Nothing else to do here. */ + return 1; + } + + /* Determine a BFD reloc value based on the operand information. + We are only prepared to turn a few of the operands into relocs. */ + + { + as_bad_where(fixp->fx_file, fixp->fx_line, + "unresolved expression that must be resolved"); + fixp->fx_done = 1; + return 1; + } + } + else if (fixp->fx_done) + { + /* We still have to insert the value into memory! */ + where = fixp->fx_frag->fr_literal + fixp->fx_where; + if (fixp->fx_size == 1) + *where = value & 0xff; + if (fixp->fx_size == 2) + bfd_putl16(value & 0xffff, (unsigned char *) where); + if (fixp->fx_size == 4) + bfd_putl32(value, (unsigned char *) where); + } + + fixp->fx_addnumber = value; + return 1; +} + + +/* Insert an operand value into an instruction. */ + +static unsigned long +mn10300_insert_operand (insn, operand, val, file, line) + unsigned long insn; + const struct mn10300_operand *operand; + offsetT val; + char *file; + unsigned int line; +{ + if (operand->bits != 16) + { + long min, max; + offsetT test; + + { + max = (1 << operand->bits) - 1; + min = 0; + } + + test = val; + + + if (test < (offsetT) min || test > (offsetT) max) + { + const char *err = + "operand out of range (%s not between %ld and %ld)"; + char buf[100]; + + sprint_value (buf, test); + if (file == (char *) NULL) + as_warn (err, buf, min, max); + else + as_warn_where (file, line, err, buf, min, max); + } + } + + insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift); + return insn; +} diff --git a/gas/config/tc-mn10x00.c b/gas/config/tc-mn10x00.c deleted file mode 100644 index db3a386..0000000 --- a/gas/config/tc-mn10x00.c +++ /dev/null @@ -1,884 +0,0 @@ -/* tc-mn10x00.c -- Assembler code for the Matsushita 10x00 - - Copyright (C) 1996 Free Software Foundation. - - This file is part of GAS, the GNU Assembler. - - GAS 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, or (at your option) - any later version. - - GAS 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 GAS; see the file COPYING. If not, write to - the Free Software Foundation, 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -#include -#include -#include "as.h" -#include "subsegs.h" -#include "opcode/mn10x00.h" - -/* Structure to hold information about predefined registers. */ -struct reg_name -{ - const char *name; - int value; -}; - -/* Generic assembler global variables which must be defined by all targets. */ - -/* Characters which always start a comment. */ -const char comment_chars[] = "#"; - -/* Characters which start a comment at the beginning of a line. */ -const char line_comment_chars[] = ";#"; - -/* Characters which may be used to separate multiple commands on a - single line. */ -const char line_separator_chars[] = ";"; - -/* Characters which are used to indicate an exponent in a floating - point number. */ -const char EXP_CHARS[] = "eE"; - -/* Characters which mean that a number is a floating point constant, - as in 0d1.0. */ -const char FLT_CHARS[] = "dD"; - - -/* local functions */ -static unsigned long mn10x00 - PARAMS ((unsigned long insn, const struct mn10x00_operand *operand, - offsetT val, char *file, unsigned int line)); -static int reg_name_search PARAMS ((const struct reg_name *, int, const char *)); -static boolean register_name PARAMS ((expressionS *expressionP)); -static boolean system_register_name PARAMS ((expressionS *expressionP)); -static boolean cc_name PARAMS ((expressionS *expressionP)); -static bfd_reloc_code_real_type mn10x00_reloc_prefix PARAMS ((void)); - - -/* fixups */ -#define MAX_INSN_FIXUPS (5) -struct mn10x00_fixup -{ - expressionS exp; - int opindex; - bfd_reloc_code_real_type reloc; -}; -struct mn10x00_fixup fixups[MAX_INSN_FIXUPS]; -static int fc; - -const char *md_shortopts = ""; -struct option md_longopts[] = { - {NULL, no_argument, NULL, 0} -}; -size_t md_longopts_size = sizeof(md_longopts); - -/* The target specific pseudo-ops which we support. */ -const pseudo_typeS md_pseudo_table[] = -{ - { NULL, NULL, 0 } -}; - -/* Opcode hash table. */ -static struct hash_control *mn10x00_hash; - -/* This table is sorted. Suitable for searching by a binary search. */ -static const struct reg_name pre_defined_registers[] = -{ - { "ep", 30 }, /* ep - element ptr */ - { "gp", 4 }, /* gp - global ptr */ - { "lp", 31 }, /* lp - link ptr */ - { "r0", 0 }, - { "r1", 1 }, - { "r10", 10 }, - { "r11", 11 }, - { "r12", 12 }, - { "r13", 13 }, - { "r14", 14 }, - { "r15", 15 }, - { "r16", 16 }, - { "r17", 17 }, - { "r18", 18 }, - { "r19", 19 }, - { "r2", 2 }, - { "r20", 20 }, - { "r21", 21 }, - { "r22", 22 }, - { "r23", 23 }, - { "r24", 24 }, - { "r25", 25 }, - { "r26", 26 }, - { "r27", 27 }, - { "r28", 28 }, - { "r29", 29 }, - { "r3", 3 }, - { "r30", 30 }, - { "r31", 31 }, - { "r4", 4 }, - { "r5", 5 }, - { "r6", 6 }, - { "r7", 7 }, - { "r8", 8 }, - { "r9", 9 }, - { "sp", 3 }, /* sp - stack ptr */ - { "tp", 5 }, /* tp - text ptr */ - { "zero", 0 }, -}; -#define REG_NAME_CNT (sizeof(pre_defined_registers) / sizeof(struct reg_name)) - - -static const struct reg_name system_registers[] = -{ - { "eipc", 0 }, - { "eipsw", 1 }, - { "fepc", 2 }, - { "fepsw", 3 }, - { "ecr", 4 }, - { "psw", 5 }, -}; -#define SYSREG_NAME_CNT (sizeof(system_registers) / sizeof(struct reg_name)) - -static const struct reg_name cc_names[] = -{ - { "c", 0x1 }, - { "ge", 0xe }, - { "gt", 0xf }, - { "h", 0xb }, - { "l", 0x1 }, - { "le", 0x7 }, - { "lt", 0x6 }, - { "n", 0x4 }, - { "nc", 0x9 }, - { "nh", 0x3 }, - { "nl", 0x9 }, - { "ns", 0xc }, - { "nv", 0x8 }, - { "nz", 0xa }, - { "p", 0xc }, - { "s", 0x4 }, - { "sa", 0xd }, - { "t", 0x5 }, - { "v", 0x0 }, - { "z", 0x2 }, -}; -#define CC_NAME_CNT (sizeof(cc_names) / sizeof(struct reg_name)) - -/* reg_name_search does a binary search of the given register table - to see if "name" is a valid regiter name. Returns the register - number from the array on success, or -1 on failure. */ - -static int -reg_name_search (regs, regcount, name) - const struct reg_name *regs; - int regcount; - const char *name; -{ - int middle, low, high; - int cmp; - - low = 0; - high = regcount - 1; - - do - { - middle = (low + high) / 2; - cmp = strcasecmp (name, regs[middle].name); - if (cmp < 0) - high = middle - 1; - else if (cmp > 0) - low = middle + 1; - else - return regs[middle].value; - } - while (low <= high); - return -1; -} - - -/* Summary of register_name(). - * - * in: Input_line_pointer points to 1st char of operand. - * - * out: A expressionS. - * The operand may have been a register: in this case, X_op == O_register, - * X_add_number is set to the register number, and truth is returned. - * Input_line_pointer->(next non-blank) char after operand, or is in - * its original state. - */ -static boolean -register_name (expressionP) - expressionS *expressionP; -{ - int reg_number; - char *name; - char *start; - char c; - - /* Find the spelling of the operand */ - start = name = input_line_pointer; - - c = get_symbol_end (); - reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name); - - /* look to see if it's in the register table */ - if (reg_number >= 0) - { - expressionP->X_op = O_register; - expressionP->X_add_number = reg_number; - - /* make the rest nice */ - expressionP->X_add_symbol = NULL; - expressionP->X_op_symbol = NULL; - *input_line_pointer = c; /* put back the delimiting char */ - return true; - } - else - { - /* reset the line as if we had not done anything */ - *input_line_pointer = c; /* put back the delimiting char */ - input_line_pointer = start; /* reset input_line pointer */ - return false; - } -} - -/* Summary of system_register_name(). - * - * in: Input_line_pointer points to 1st char of operand. - * - * out: A expressionS. - * The operand may have been a register: in this case, X_op == O_register, - * X_add_number is set to the register number, and truth is returned. - * Input_line_pointer->(next non-blank) char after operand, or is in - * its original state. - */ -static boolean -system_register_name (expressionP) - expressionS *expressionP; -{ - int reg_number; - char *name; - char *start; - char c; - - /* Find the spelling of the operand */ - start = name = input_line_pointer; - - c = get_symbol_end (); - reg_number = reg_name_search (system_registers, SYSREG_NAME_CNT, name); - - /* look to see if it's in the register table */ - if (reg_number >= 0) - { - expressionP->X_op = O_register; - expressionP->X_add_number = reg_number; - - /* make the rest nice */ - expressionP->X_add_symbol = NULL; - expressionP->X_op_symbol = NULL; - *input_line_pointer = c; /* put back the delimiting char */ - return true; - } - else - { - /* reset the line as if we had not done anything */ - *input_line_pointer = c; /* put back the delimiting char */ - input_line_pointer = start; /* reset input_line pointer */ - return false; - } -} - -/* Summary of cc_name(). - * - * in: Input_line_pointer points to 1st char of operand. - * - * out: A expressionS. - * The operand may have been a register: in this case, X_op == O_register, - * X_add_number is set to the register number, and truth is returned. - * Input_line_pointer->(next non-blank) char after operand, or is in - * its original state. - */ -static boolean -cc_name (expressionP) - expressionS *expressionP; -{ - int reg_number; - char *name; - char *start; - char c; - - /* Find the spelling of the operand */ - start = name = input_line_pointer; - - c = get_symbol_end (); - reg_number = reg_name_search (cc_names, CC_NAME_CNT, name); - - /* look to see if it's in the register table */ - if (reg_number >= 0) - { - expressionP->X_op = O_constant; - expressionP->X_add_number = reg_number; - - /* make the rest nice */ - expressionP->X_add_symbol = NULL; - expressionP->X_op_symbol = NULL; - *input_line_pointer = c; /* put back the delimiting char */ - return true; - } - else - { - /* reset the line as if we had not done anything */ - *input_line_pointer = c; /* put back the delimiting char */ - input_line_pointer = start; /* reset input_line pointer */ - return false; - } -} - -void -md_show_usage (stream) - FILE *stream; -{ - fprintf(stream, "MN10x00 options:\n\ -none yet\n"); -} - -int -md_parse_option (c, arg) - int c; - char *arg; -{ - return 0; -} - -symbolS * -md_undefined_symbol (name) - char *name; -{ - return 0; -} - -char * -md_atof (type, litp, sizep) - int type; - char *litp; - int *sizep; -{ - int prec; - LITTLENUM_TYPE words[4]; - char *t; - int i; - - switch (type) - { - case 'f': - prec = 2; - break; - - case 'd': - prec = 4; - break; - - default: - *sizep = 0; - return "bad call to md_atof"; - } - - t = atof_ieee (input_line_pointer, type, words); - if (t) - input_line_pointer = t; - - *sizep = prec * 2; - - for (i = prec - 1; i >= 0; i--) - { - md_number_to_chars (litp, (valueT) words[i], 2); - litp += 2; - } - - return NULL; -} - - -void -md_convert_frag (abfd, sec, fragP) - bfd *abfd; - asection *sec; - fragS *fragP; -{ - /* printf ("call to md_convert_frag \n"); */ - abort (); -} - -valueT -md_section_align (seg, addr) - asection *seg; - valueT addr; -{ - int align = bfd_get_section_alignment (stdoutput, seg); - return ((addr + (1 << align) - 1) & (-1 << align)); -} - -void -md_begin () -{ - char *prev_name = ""; - register const struct mn10x00_opcode *op; - - mn10x00_hash = hash_new(); - - /* Insert unique names into hash table. The MN10x00 instruction set - has many identical opcode names that have different opcodes based - on the operands. This hash table then provides a quick index to - the first opcode with a particular name in the opcode table. */ - - op = mn10x00_opcodes; - while (op->name) - { - if (strcmp (prev_name, op->name)) - { - prev_name = (char *) op->name; - hash_insert (mn10x00_hash, op->name, (char *) op); - } - op++; - } -} - -static bfd_reloc_code_real_type -mn10x00_reloc_prefix() -{ - if (strncmp(input_line_pointer, "hi0(", 4) == 0) - { - input_line_pointer += 4; - return BFD_RELOC_HI16; - } - if (strncmp(input_line_pointer, "hi(", 3) == 0) - { - input_line_pointer += 3; - return BFD_RELOC_HI16_S; - } - if (strncmp (input_line_pointer, "lo(", 3) == 0) - { - input_line_pointer += 3; - return BFD_RELOC_LO16; - } - - /* FIXME: implement sda, tda, zda here */ - - return BFD_RELOC_UNUSED; -} - -void -md_assemble (str) - char *str; -{ - char *s; - struct mn10x00_opcode *opcode; - struct mn10x00_opcode *next_opcode; - const unsigned char *opindex_ptr; - int next_opindex; - unsigned long insn, size; - char *f; - int i; - int match; - bfd_reloc_code_real_type reloc; - - /* Get the opcode. */ - for (s = str; *s != '\0' && ! isspace (*s); s++) - ; - if (*s != '\0') - *s++ = '\0'; - - /* find the first opcode with the proper name */ - opcode = (struct mn10x00_opcode *)hash_find (mn10x00_hash, str); - if (opcode == NULL) - { - as_bad ("Unrecognized opcode: `%s'", str); - return; - } - - str = s; - while (isspace (*str)) - ++str; - - input_line_pointer = str; - - for(;;) - { - const char *errmsg = NULL; - - fc = 0; - match = 0; - next_opindex = 0; - insn = opcode->opcode; - for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++) - { - const struct mn10x00_operand *operand; - char *hold; - expressionS ex; - - if (next_opindex == 0) - { - operand = &mn10x00_operands[*opindex_ptr]; - } - else - { - operand = &mn10x00_operands[next_opindex]; - next_opindex = 0; - } - - errmsg = NULL; - - while (*str == ' ' || *str == ',' || *str == '[' || *str == ']') - ++str; - - /* Gather the operand. */ - hold = input_line_pointer; - input_line_pointer = str; - - - /* lo(), hi(), hi0(), etc... */ - if ((reloc = mn10x00_reloc_prefix()) != BFD_RELOC_UNUSED) - { - expression(&ex); - - if (*input_line_pointer++ != ')') - { - errmsg = "syntax error: expected `)'"; - goto error; - } - - if (ex.X_op == O_constant) - { - switch (reloc) - { - case BFD_RELOC_LO16: - ex.X_add_number &= 0xffff; - break; - - case BFD_RELOC_HI16: - ex.X_add_number = ((ex.X_add_number >> 16) & 0xffff); - break; - - case BFD_RELOC_HI16_S: - ex.X_add_number = ((ex.X_add_number >> 16) & 0xffff) - + ((ex.X_add_number >> 15) & 1); - break; - - default: - break; - } - - insn = mn10x00_insert_operand (insn, operand, ex.X_add_number, - (char *) NULL, 0); - } - else - { - if (fc > MAX_INSN_FIXUPS) - as_fatal ("too many fixups"); - - fixups[fc].exp = ex; - fixups[fc].opindex = *opindex_ptr; - fixups[fc].reloc = reloc; - fc++; - } - } - else - { - switch (ex.X_op) - { - case O_illegal: - errmsg = "illegal operand"; - goto error; - case O_absent: - errmsg = "missing operand"; - goto error; - case O_register: - - insn = mn10x00_insert_operand (insn, operand, ex.X_add_number, - (char *) NULL, 0); - break; - - case O_constant: - insn = mn10x00_insert_operand (insn, operand, ex.X_add_number, - (char *) NULL, 0); - break; - - default: - /* We need to generate a fixup for this expression. */ - if (fc >= MAX_INSN_FIXUPS) - as_fatal ("too many fixups"); - fixups[fc].exp = ex; - fixups[fc].opindex = *opindex_ptr; - fixups[fc].reloc = BFD_RELOC_UNUSED; - ++fc; - break; - } - - } - - str = input_line_pointer; - input_line_pointer = hold; - - while (*str == ' ' || *str == ',' || *str == '[' || *str == ']') - ++str; - } - match = 1; - - error: - if (match == 0) - { - next_opcode = opcode + 1; - if (next_opcode->opcode != 0 && !strcmp(next_opcode->name, opcode->name)) - { - opcode = next_opcode; - continue; - } - - as_bad ("%s", errmsg); - return; - } - break; - } - - while (isspace (*str)) - ++str; - - if (*str != '\0') - as_bad ("junk at end of line: `%s'", str); - - input_line_pointer = str; - - /* Write out the instruction. - - Four byte insns have an opcode with the two high bits on. */ - if ((insn & 0x0600) == 0x0600) - size = 4; - else - size = 2; - f = frag_more (size); - md_number_to_chars (f, insn, size); - - /* Create any fixups. At this point we do not use a - bfd_reloc_code_real_type, but instead just use the - BFD_RELOC_UNUSED plus the operand index. This lets us easily - handle fixups for any operand type, although that is admittedly - not a very exciting feature. We pick a BFD reloc type in - md_apply_fix. */ - for (i = 0; i < fc; i++) - { - const struct mn10x00_operand *operand; - - operand = &mn10x00_operands[fixups[i].opindex]; - if (fixups[i].reloc != BFD_RELOC_UNUSED) - { - reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc); - int size; - int offset; - fixS *fixP; - - if (!reloc_howto) - abort(); - - size = bfd_get_reloc_size (reloc_howto); - offset = 4 - size; - - if (size < 1 || size > 4) - abort(); - - fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset, size, - &fixups[i].exp, - reloc_howto->pc_relative, - fixups[i].reloc); - } - else - { - fix_new_exp (frag_now, f - frag_now->fr_literal, 4, - &fixups[i].exp, - 1 /* FIXME: MN10x00_OPERAND_RELATIVE ??? */, - ((bfd_reloc_code_real_type) - (fixups[i].opindex + (int) BFD_RELOC_UNUSED))); - } - } -} - - -/* if while processing a fixup, a reloc really needs to be created */ -/* then it is done here */ - -arelent * -tc_gen_reloc (seg, fixp) - asection *seg; - fixS *fixp; -{ - arelent *reloc; - reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent)); - reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym; - reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; - reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type); - if (reloc->howto == (reloc_howto_type *) NULL) - { - as_bad_where (fixp->fx_file, fixp->fx_line, - "reloc %d not supported by object file format", (int)fixp->fx_r_type); - return NULL; - } - reloc->addend = fixp->fx_addnumber; - /* printf("tc_gen_reloc: addr=%x addend=%x\n", reloc->address, reloc->addend); */ - return reloc; -} - -int -md_estimate_size_before_relax (fragp, seg) - fragS *fragp; - asection *seg; -{ - return 0; -} - -long -md_pcrel_from (fixp) - fixS *fixp; -{ - if (fixp->fx_addsy != (symbolS *) NULL && ! S_IS_DEFINED (fixp->fx_addsy)) - { - /* The symbol is undefined. Let the linker figure it out. */ - return 0; - } - return fixp->fx_frag->fr_address + fixp->fx_where; -} - -int -md_apply_fix3 (fixp, valuep, seg) - fixS *fixp; - valueT *valuep; - segT seg; -{ - valueT value; - char *where; - - if (fixp->fx_addsy == (symbolS *) NULL) - { - value = *valuep; - fixp->fx_done = 1; - } - else if (fixp->fx_pcrel) - value = *valuep; - else - { - value = fixp->fx_offset; - if (fixp->fx_subsy != (symbolS *) NULL) - { - if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section) - value -= S_GET_VALUE (fixp->fx_subsy); - else - { - /* We don't actually support subtracting a symbol. */ - as_bad_where (fixp->fx_file, fixp->fx_line, - "expression too complex"); - } - } - } - - /* printf("md_apply_fix: value=0x%x type=%d\n", value, fixp->fx_r_type); */ - - if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED) - { - int opindex; - const struct mn10x00_operand *operand; - char *where; - unsigned long insn; - - opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED; - operand = &mn10x00_operands[opindex]; - - /* Fetch the instruction, insert the fully resolved operand - value, and stuff the instruction back again. - - Note the instruction has been stored in little endian - format! */ - where = fixp->fx_frag->fr_literal + fixp->fx_where; - - insn = bfd_getl32((unsigned char *) where); - insn = mn10x00_insert_operand (insn, operand, (offsetT) value, - fixp->fx_file, fixp->fx_line); - bfd_putl32((bfd_vma) insn, (unsigned char *) where); - - if (fixp->fx_done) - { - /* Nothing else to do here. */ - return 1; - } - - /* Determine a BFD reloc value based on the operand information. - We are only prepared to turn a few of the operands into relocs. */ - - { - as_bad_where(fixp->fx_file, fixp->fx_line, - "unresolved expression that must be resolved"); - fixp->fx_done = 1; - return 1; - } - } - else if (fixp->fx_done) - { - /* We still have to insert the value into memory! */ - where = fixp->fx_frag->fr_literal + fixp->fx_where; - if (fixp->fx_size == 1) - *where = value & 0xff; - if (fixp->fx_size == 2) - bfd_putl16(value & 0xffff, (unsigned char *) where); - if (fixp->fx_size == 4) - bfd_putl32(value, (unsigned char *) where); - } - - fixp->fx_addnumber = value; - return 1; -} - - -/* Insert an operand value into an instruction. */ - -static unsigned long -mn10x00_insert_operand (insn, operand, val, file, line) - unsigned long insn; - const struct mn10x00_operand *operand; - offsetT val; - char *file; - unsigned int line; -{ - if (operand->bits != 16) - { - long min, max; - offsetT test; - - { - max = (1 << operand->bits) - 1; - min = 0; - } - - test = val; - - - if (test < (offsetT) min || test > (offsetT) max) - { - const char *err = - "operand out of range (%s not between %ld and %ld)"; - char buf[100]; - - sprint_value (buf, test); - if (file == (char *) NULL) - as_warn (err, buf, min, max); - else - as_warn_where (file, line, err, buf, min, max); - } - } - - insn |= (((long) val & ((1 << operand->bits) - 1)) << operand->shift); - return insn; -} diff --git a/gas/config/tc-mn10x00.h b/gas/config/tc-mn10x00.h deleted file mode 100644 index c5b2add..0000000 --- a/gas/config/tc-mn10x00.h +++ /dev/null @@ -1,48 +0,0 @@ -/* tc-mn10x00.h -- Header file for tc-mn10x00.c. - Copyright (C) 1996 Free Software Foundation, Inc. - - This file is part of GAS, the GNU Assembler. - - GAS 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, or (at your option) - any later version. - - GAS 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 GAS; see the file COPYING. If not, write to - the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ - -#define TC_MN10x00 - -#ifndef BFD_ASSEMBLER - #error MN10x00 support requires BFD_ASSEMBLER -#endif - -/* The target BFD architecture. */ -#define TARGET_ARCH bfd_arch_mn10x00 - -#define TARGET_FORMAT "elf32-mn10x00" - -#define MD_APPLY_FIX3 -#define md_operand(x) - -/* Permit temporary numeric labels. */ -#define LOCAL_LABELS_FB 1 - -#define LOCAL_LABEL(name) ((name[0] == '.' \ - && (name[1] == 'L' || name[1] == '.')) \ - || (name[0] == '_' && name[1] == '.' && name[2] == 'L' \ - && name[3] == '_')) - -#define FAKE_LABEL_NAME ".L0\001" -#define DIFF_EXPR_OK /* .-foo gets turned into PC relative relocs */ - -/* We don't need to handle .word strangely. */ -#define WORKING_DOT_WORD - -#define md_number_to_chars number_to_chars_littleendian diff --git a/gas/configure b/gas/configure index b53b1e2..6791818 100755 --- a/gas/configure +++ b/gas/configure @@ -876,7 +876,8 @@ for this_target in $target $canon_targets ; do *) targ=mips-lit ;; esac ;; - mn10x00-*-*) fmt=elf bfd_gas=yes ;; + mn10200-*-*) fmt=elf bfd_gas=yes ;; + mn10300-*-*) fmt=elf bfd_gas=yes ;; ppc-*-pe | ppc-*-cygwin32 | ppc-*-winnt*) fmt=coff em=pe case "$endian" in diff --git a/gas/configure.in b/gas/configure.in index 3735f4b..8325e03 100644 --- a/gas/configure.in +++ b/gas/configure.in @@ -230,7 +230,8 @@ changequote([,])dnl *) targ=mips-lit ;; esac ;; - mn10x00-*-*) fmt=elf bfd_gas=yes ;; + mn10200-*-*) fmt=elf bfd_gas=yes ;; + mn10300-*-*) fmt=elf bfd_gas=yes ;; ppc-*-pe | ppc-*-cygwin32 | ppc-*-winnt*) fmt=coff em=pe case "$endian" in diff --git a/gas/testsuite/ChangeLog b/gas/testsuite/ChangeLog index 397cfd3..02d0a5c 100644 --- a/gas/testsuite/ChangeLog +++ b/gas/testsuite/ChangeLog @@ -1,6 +1,7 @@ -Thu Oct 3 00:14:04 1996 Jeffrey A Law (law@cygnus.com) +Thu Oct 3 09:57:03 1996 Jeffrey A Law (law@cygnus.com) - * gas/mn10x00: New directory for Matsushita 10x00 tests. + * gas/mn10200, gas/mn10300: New directorys for Matsushita + mn10200 and mn10300 tests. Tue Oct 1 15:38:28 1996 Ian Lance Taylor diff --git a/gas/testsuite/gas/.Sanitize b/gas/testsuite/gas/.Sanitize index 2dc9ec2..9be0821a 100644 --- a/gas/testsuite/gas/.Sanitize +++ b/gas/testsuite/gas/.Sanitize @@ -48,7 +48,8 @@ m68k m68k-coff macros mips -mn10x00 +mn10200 +mn10300 mri sh sparc diff --git a/include/ChangeLog b/include/ChangeLog index 79b16d4..a63b82c 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,3 +1,8 @@ +Thu Oct 3 10:33:14 1996 Jeffrey A Law (law@cygnus.com) + + * dis-asm.h (print_insn_mn10x00): Delete declaration. + (print_insn_mn10200, print_insn_mn10300): Declare. + Wed Oct 2 21:24:43 1996 Jeffrey A Law (law@cygnus.com) * dis-asm.h (print_insn_mn10x00): Declare. diff --git a/include/dis-asm.h b/include/dis-asm.h index 3a05927..e38331b 100644 --- a/include/dis-asm.h +++ b/include/dis-asm.h @@ -131,7 +131,8 @@ extern int print_insn_sh PARAMS ((bfd_vma, disassemble_info*)); extern int print_insn_shl PARAMS ((bfd_vma, disassemble_info*)); extern int print_insn_hppa PARAMS ((bfd_vma, disassemble_info*)); extern int print_insn_m88k PARAMS ((bfd_vma, disassemble_info*)); -extern int print_insn_mn10x00 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_mn10200 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_mn10300 PARAMS ((bfd_vma, disassemble_info*)); extern int print_insn_ns32k PARAMS ((bfd_vma, disassemble_info*)); extern int print_insn_big_powerpc PARAMS ((bfd_vma, disassemble_info*)); extern int print_insn_little_powerpc PARAMS ((bfd_vma, disassemble_info*)); diff --git a/include/elf/ChangeLog b/include/elf/ChangeLog index dac3d6e..3c1c42b 100644 --- a/include/elf/ChangeLog +++ b/include/elf/ChangeLog @@ -1,3 +1,7 @@ +Thu Oct 3 10:01:40 1996 Jeffrey A Law (law@cygnus.com) + + * common.h: Break mn10x00 support into mn10200 and mn10300. + Wed Oct 2 21:26:43 1996 Jeffrey A Law (law@cygnus.com) * common.h (EM_CYGNUS_MN10x00): Define. diff --git a/include/opcode/.Sanitize b/include/opcode/.Sanitize index 81362b3..e9cf078 100644 --- a/include/opcode/.Sanitize +++ b/include/opcode/.Sanitize @@ -61,7 +61,8 @@ i960.h m68k.h m88k.h mips.h -mn10x00.h +mn10200.h +mn10300.h np1.h ns32k.h pn.h diff --git a/include/opcode/ChangeLog b/include/opcode/ChangeLog index 48dd515..56817b3 100644 --- a/include/opcode/ChangeLog +++ b/include/opcode/ChangeLog @@ -1,3 +1,8 @@ +Thu Oct 3 10:33:46 1996 Jeffrey A Law (law@cygnus.com) + + * mn10x00.h: Delete. + * mn10200.h, mn10300.h: New files. + Wed Oct 2 21:31:26 1996 Jeffrey A Law (law@cygnus.com) * mn10x00.h: New file. diff --git a/include/opcode/mn10300.h b/include/opcode/mn10300.h new file mode 100644 index 0000000..2d780b1 --- /dev/null +++ b/include/opcode/mn10300.h @@ -0,0 +1,75 @@ +/* mn10300.h -- Header file for Matsushita 10300 opcode table + Copyright 1996 Free Software Foundation, Inc. + Written by Jeff Law, Cygnus Support + +This file is part of GDB, GAS, and the GNU binutils. + +GDB, GAS, and the GNU binutils are free software; you can redistribute +them and/or modify them under the terms of the GNU General Public +License as published by the Free Software Foundation; either version +1, or (at your option) any later version. + +GDB, GAS, and the GNU binutils are distributed in the hope that they +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 file; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#ifndef MN10300_H +#define MN10300_H + +/* The opcode table is an array of struct mn10300_opcode. */ + +struct mn10300_opcode +{ + /* The opcode name. */ + const char *name; + + /* The opcode itself. Those bits which will be filled in with + operands are zeroes. */ + unsigned long opcode; + + /* The opcode mask. This is used by the disassembler. This is a + mask containing ones indicating those bits which must match the + opcode field, and zeroes indicating those bits which need not + match (and are presumably filled in by operands). */ + unsigned long mask; + + /* An array of operand codes. Each code is an index into the + operand table. They appear in the order which the operands must + appear in assembly code, and are terminated by a zero. */ + unsigned char operands[8]; +}; + +/* The table itself is sorted by major opcode number, and is otherwise + in the order in which the disassembler should consider + instructions. */ +extern const struct mn10300_opcode mn10300_opcodes[]; +extern const int mn10300_num_opcodes; + + +/* The operands table is an array of struct powerpc_operand. */ + +struct mn10300_operand +{ + /* The number of bits in the operand. */ + int bits; + + /* How far the operand is left shifted in the instruction. */ + int shift; + + /* One bit syntax flags. */ + int flags; +}; + +/* Elements in the table are retrieved by indexing with values from + the operands field of the mn10300_opcodes table. */ + +extern const struct mn10300_operand mn10300_operands[]; + +/* Values defined for the flags field of a struct mn10300_operand. */ + +#endif /* MN10300_H */ diff --git a/include/opcode/mn10x00.h b/include/opcode/mn10x00.h deleted file mode 100644 index b09387f..0000000 --- a/include/opcode/mn10x00.h +++ /dev/null @@ -1,75 +0,0 @@ -/* mn10x00.h -- Header file for Matsushita 10200 and 10300 opcode table - Copyright 1996 Free Software Foundation, Inc. - Written by Jeff Law, Cygnus Support - -This file is part of GDB, GAS, and the GNU binutils. - -GDB, GAS, and the GNU binutils are free software; you can redistribute -them and/or modify them under the terms of the GNU General Public -License as published by the Free Software Foundation; either version -1, or (at your option) any later version. - -GDB, GAS, and the GNU binutils are distributed in the hope that they -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 file; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ - -#ifndef MN10x00_H -#define MN10x00_H - -/* The opcode table is an array of struct mn10x00_opcode. */ - -struct mn10x00_opcode -{ - /* The opcode name. */ - const char *name; - - /* The opcode itself. Those bits which will be filled in with - operands are zeroes. */ - unsigned long opcode; - - /* The opcode mask. This is used by the disassembler. This is a - mask containing ones indicating those bits which must match the - opcode field, and zeroes indicating those bits which need not - match (and are presumably filled in by operands). */ - unsigned long mask; - - /* An array of operand codes. Each code is an index into the - operand table. They appear in the order which the operands must - appear in assembly code, and are terminated by a zero. */ - unsigned char operands[8]; -}; - -/* The table itself is sorted by major opcode number, and is otherwise - in the order in which the disassembler should consider - instructions. */ -extern const struct mn10x00_opcode mn10x00_opcodes[]; -extern const int mn10x00_num_opcodes; - - -/* The operands table is an array of struct powerpc_operand. */ - -struct mn10x00_operand -{ - /* The number of bits in the operand. */ - int bits; - - /* How far the operand is left shifted in the instruction. */ - int shift; - - /* One bit syntax flags. */ - int flags; -}; - -/* Elements in the table are retrieved by indexing with values from - the operands field of the mn10x00_opcodes table. */ - -extern const struct mn10x00_operand mn10x00_operands[]; - -/* Values defined for the flags field of a struct mn10x00_operand. */ - -#endif /* MN10x00_H */ diff --git a/opcodes/.Sanitize b/opcodes/.Sanitize index 4c61e37..4aa3000 100644 --- a/opcodes/.Sanitize +++ b/opcodes/.Sanitize @@ -74,6 +74,10 @@ m88k-dis.c makefile.vms mips-dis.c mips-opc.c +mn10200-dis.c +mn10200-opc.c +mn10300-dis.c +mn10300-opc.c mpw-config.in mpw-make.sed ns32k-dis.c diff --git a/opcodes/ChangeLog b/opcodes/ChangeLog index de99849..b9ee3181 100644 --- a/opcodes/ChangeLog +++ b/opcodes/ChangeLog @@ -1,3 +1,13 @@ +Thu Oct 3 10:06:07 1996 Jeffrey A Law (law@cygnus.com) + + * mn10200-opc.c, mn10300-opc.c: New files. + * mn10200-dis.c, mn10300-dis.c: New files. + * mn10x00-opc.c, mn10x00-dis.c: Deleted. + * disassemble.c: Break mn10x00 support into 10200 and 10300 + support. + * configure.in: Likewise. + * configure: Rebuilt. + Thu Oct 3 15:59:12 1996 Jason Molenda (crash@godzilla.cygnus.co.jp) * Makefile.in (MOSTLYCLEAN): Move config.log to distclean. diff --git a/opcodes/mn10200-dis.c b/opcodes/mn10200-dis.c new file mode 100644 index 0000000..5aa0cb8 --- /dev/null +++ b/opcodes/mn10200-dis.c @@ -0,0 +1,34 @@ +/* Disassemble MN10200 instructions. + Copyright (C) 1996 Free Software Foundation, Inc. + +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 + +#include "ansidecl.h" +#include "opcode/mn10200.h" +#include "dis-asm.h" + +static void disassemble PARAMS ((bfd_vma memaddr, + struct disassemble_info *info, + unsigned long insn)); + +int +print_insn_mn10200 (memaddr, info) + bfd_vma memaddr; + struct disassemble_info *info; +{ +} diff --git a/opcodes/mn10200-opc.c b/opcodes/mn10200-opc.c new file mode 100644 index 0000000..7b4abfa --- /dev/null +++ b/opcodes/mn10200-opc.c @@ -0,0 +1,51 @@ +/* Assemble Matsushita MN10200 instructions. + Copyright (C) 1996 Free Software Foundation, Inc. + +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 "ansidecl.h" +#include "opcode/mn10200.h" + + +const struct mn10200_operand mn10200_operands[] = { +#define UNUSED 0 + { 0, 0, 0 }, +} ; + + +/* The opcode table. + + The format of the opcode table is: + + NAME OPCODE MASK { OPERANDS } + + NAME is the name of the instruction. + OPCODE is the instruction opcode. + MASK is the opcode mask; this is used to tell the disassembler + which bits in the actual opcode must match OPCODE. + OPERANDS is the list of operands. + + The disassembler reads the table in order and prints the first + instruction which matches, so this table is sorted to put more + specific instructions before more general instructions. It is also + sorted by major opcode. */ + +const struct mn10200_opcode mn10200_opcodes[] = { +{ 0, 0, 0, {0}, } } ; + +const int mn10200_num_opcodes = + sizeof (mn10200_opcodes) / sizeof (mn10200_opcodes[0]); + + diff --git a/opcodes/mn10300-dis.c b/opcodes/mn10300-dis.c new file mode 100644 index 0000000..b81d493 --- /dev/null +++ b/opcodes/mn10300-dis.c @@ -0,0 +1,34 @@ +/* Disassemble MN10300 instructions. + Copyright (C) 1996 Free Software Foundation, Inc. + +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 + +#include "ansidecl.h" +#include "opcode/mn10300.h" +#include "dis-asm.h" + +static void disassemble PARAMS ((bfd_vma memaddr, + struct disassemble_info *info, + unsigned long insn)); + +int +print_insn_mn10300 (memaddr, info) + bfd_vma memaddr; + struct disassemble_info *info; +{ +} diff --git a/opcodes/mn10300-opc.c b/opcodes/mn10300-opc.c new file mode 100644 index 0000000..800a45b --- /dev/null +++ b/opcodes/mn10300-opc.c @@ -0,0 +1,51 @@ +/* Assemble Matsushita MN10300 instructions. + Copyright (C) 1996 Free Software Foundation, Inc. + +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 "ansidecl.h" +#include "opcode/mn10300.h" + + +const struct mn10300_operand mn10300_operands[] = { +#define UNUSED 0 + { 0, 0, 0 }, +} ; + + +/* The opcode table. + + The format of the opcode table is: + + NAME OPCODE MASK { OPERANDS } + + NAME is the name of the instruction. + OPCODE is the instruction opcode. + MASK is the opcode mask; this is used to tell the disassembler + which bits in the actual opcode must match OPCODE. + OPERANDS is the list of operands. + + The disassembler reads the table in order and prints the first + instruction which matches, so this table is sorted to put more + specific instructions before more general instructions. It is also + sorted by major opcode. */ + +const struct mn10300_opcode mn10300_opcodes[] = { +{ 0, 0, 0, {0}, } } ; + +const int mn10300_num_opcodes = + sizeof (mn10300_opcodes) / sizeof (mn10300_opcodes[0]); + + diff --git a/opcodes/mn10x00-dis.c b/opcodes/mn10x00-dis.c deleted file mode 100755 index cd068e3..0000000 --- a/opcodes/mn10x00-dis.c +++ /dev/null @@ -1,34 +0,0 @@ -/* Disassemble MN10x00 instructions. - Copyright (C) 1996 Free Software Foundation, Inc. - -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 - -#include "ansidecl.h" -#include "opcode/mn10x00.h" -#include "dis-asm.h" - -static void disassemble PARAMS ((bfd_vma memaddr, - struct disassemble_info *info, - unsigned long insn)); - -int -print_insn_mn10x00 (memaddr, info) - bfd_vma memaddr; - struct disassemble_info *info; -{ -} diff --git a/opcodes/mn10x00-opc.c b/opcodes/mn10x00-opc.c deleted file mode 100644 index 278756b..0000000 --- a/opcodes/mn10x00-opc.c +++ /dev/null @@ -1,51 +0,0 @@ -/* Assemble Matsushita MN10x00 instructions. - Copyright (C) 1996 Free Software Foundation, Inc. - -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 "ansidecl.h" -#include "opcode/mn10x00.h" - - -const struct mn10x00_operand mn10x00_operands[] = { -#define UNUSED 0 - { 0, 0, 0 }, -} ; - - -/* The opcode table. - - The format of the opcode table is: - - NAME OPCODE MASK { OPERANDS } - - NAME is the name of the instruction. - OPCODE is the instruction opcode. - MASK is the opcode mask; this is used to tell the disassembler - which bits in the actual opcode must match OPCODE. - OPERANDS is the list of operands. - - The disassembler reads the table in order and prints the first - instruction which matches, so this table is sorted to put more - specific instructions before more general instructions. It is also - sorted by major opcode. */ - -const struct mn10x00_opcode mn10x00_opcodes[] = { -{ 0, 0, 0, {0}, } } ; - -const int mn10x00_num_opcodes = - sizeof (mn10x00_opcodes) / sizeof (mn10x00_opcodes[0]); - - -- cgit v1.1