* configure: Regenerate.
* Makefile.am: (CPU_TYPES): Add cris.
(CPU_OBJ_VALID) [aout]: Add cris.
(MULTI_CPU_TYPES): Add cris.
(MULTI_CPU_OBJ_VALID) [aout]: Add cris.
[coff]: Only i386 and mips are valid.
(TARGET_CPU_CFILES): Add config/tc-cris.c.
(TARGET_CPU_HFILES): Add config/tc-cris.h.
(MULTI_CFILES): Add config/e-crisaout.c and config/e-criself.c.
Regenerate dependencies.
* Makefile.in: Regenerate.
* aclocal.m4: Regenerate.
* as.c: Declare crisaout, criself.
* config/tc-cris.h, config/tc-cris.c: New.
* config/e-criself.c, config/e-crisaout.c: New.
* po/POTFILES.in, po/gas.pot: Regenerate.
+2000-07-20 Hans-Peter Nilsson <hp@axis.com>
+
+ * configure.in: Add CRIS support.
+ * configure: Regenerate.
+ * Makefile.am: (CPU_TYPES): Add cris.
+ (CPU_OBJ_VALID) [aout]: Add cris.
+ (MULTI_CPU_TYPES): Add cris.
+ (MULTI_CPU_OBJ_VALID) [aout]: Add cris.
+ [coff]: Only i386 and mips are valid.
+ (TARGET_CPU_CFILES): Add config/tc-cris.c.
+ (TARGET_CPU_HFILES): Add config/tc-cris.h.
+ (MULTI_CFILES): Add config/e-crisaout.c and config/e-criself.c.
+ Regenerate dependencies.
+ * Makefile.in: Regenerate.
+ * aclocal.m4: Regenerate.
+ * as.c: Declare crisaout, criself.
+ * config/tc-cris.h, config/tc-cris.c: New.
+ * config/e-criself.c, config/e-crisaout.c: New.
+ * po/POTFILES.in, po/gas.pot: Regenerate.
+
2000-07-20 Kazu Hirata <kazu@hxi.com>
* read.c: Fix formatting.
arc \
arm \
avr \
+ cris \
d10v \
d30v \
fr30 \
case $$o in \
aout) \
case $$c in \
- a29k | arm | i386 | i860 | m68k | mips | ns32k | sparc | tahoe | tic30 | vax) \
+ a29k | arm | cris | i386 | i860 | m68k | mips | ns32k | sparc | tahoe | tic30 | vax) \
valid=yes ;; \
esac ;; \
bout) \
# These are like CPU_TYPES and CPU_OBJ_VALID, for the obj=multi case.
-MULTI_CPU_TYPES = i386 mips
+MULTI_CPU_TYPES = i386 mips cris
MULTI_CPU_OBJ_VALID = \
valid= ; \
case $$o in \
aout) \
case $$c in \
- i386) valid=yes ;; \
+ i386 | cris) valid=yes ;; \
+ esac ;; \
+ coff) \
+ case $$c in \
+ i386 | mips) valid=yes ;; \
esac ;; \
- coff) valid=yes ;; \
ecoff) \
case $$c in \
mips) valid=yes ;; \
config/tc-arc.c \
config/tc-arm.c \
config/tc-avr.c \
+ config/tc-cris.c \
config/tc-d10v.c \
config/tc-d30v.c \
config/tc-fr30.c \
config/tc-arc.h \
config/tc-arm.h \
config/tc-avr.h \
+ config/tc-cris.h \
config/tc-d10v.h \
config/tc-d30v.h \
config/tc-fr30.h \
# Multi files in config
MULTI_CFILES = \
+ config/e-crisaout.c \
+ config/e-criself.c \
config/e-i386aout.c \
config/e-i386coff.c \
config/e-i386elf.c \
$(COMPILE) -c $(srcdir)/config/e-i386coff.c
e-i386elf.o: $(srcdir)/config/e-i386elf.c
$(COMPILE) -c $(srcdir)/config/e-i386elf.c
+e-crisaout.o: $(srcdir)/config/e-crisaout.c
+ $(COMPILE) -c $(srcdir)/config/e-crisaout.c
+e-criself.o: $(srcdir)/config/e-criself.c
+ $(COMPILE) -c $(srcdir)/config/e-criself.c
# The m68k operand parser.
$(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
$(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr.h subsegs.h \
$(INCDIR)/obstack.h $(INCDIR)/opcode/avr.h
+DEPTC_cris_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-cris.h \
+ $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h subsegs.h $(INCDIR)/obstack.h \
+ $(INCDIR)/opcode/cris.h
+DEPTC_cris_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-cris.h \
+ $(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
+ subsegs.h $(INCDIR)/obstack.h $(INCDIR)/opcode/cris.h
+DEPTC_cris_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
+ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
+ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-cris.h subsegs.h \
+ $(INCDIR)/obstack.h $(INCDIR)/opcode/cris.h
DEPTC_d10v_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-d10v.h \
$(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
subsegs.h $(INCDIR)/obstack.h $(INCDIR)/opcode/d10v.h \
$(INCDIR)/obstack.h $(srcdir)/../opcodes/h8500-opc.h
DEPTC_hppa_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-hppa.h \
$(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
- subsegs.h $(INCDIR)/obstack.h $(BFDDIR)/libhppa.h $(BFDDIR)/libbfd.h \
- $(INCDIR)/opcode/hppa.h
+ subsegs.h $(INCDIR)/obstack.h $(BFDDIR)/libhppa.h $(INCDIR)/opcode/hppa.h
DEPTC_hppa_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
$(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
$(INCDIR)/bfdlink.h $(srcdir)/config/tc-hppa.h $(BFDDIR)/elf32-hppa.h \
$(BFDDIR)/libhppa.h $(INCDIR)/elf/hppa.h $(INCDIR)/elf/reloc-macros.h \
- subsegs.h $(INCDIR)/obstack.h $(BFDDIR)/libbfd.h $(INCDIR)/opcode/hppa.h \
+ subsegs.h $(INCDIR)/obstack.h $(INCDIR)/opcode/hppa.h \
dwarf2dbg.h
DEPTC_ia64_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-ia64.h \
$(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
$(DEPTC_i386_elf)
DEPTC_mips_multi = $(DEPTC_mips_coff) $(DEPTC_mips_ecoff) \
$(DEPTC_mips_elf)
+DEPTC_cris_multi = $(DEPTC_cris_aout) $(DEPTC_cris_elf)
DEPOBJ_a29k_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-a29k.h \
$(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h $(INCDIR)/aout/aout64.h \
$(INCDIR)/obstack.h
$(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
$(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr.h subsegs.h \
$(INCDIR)/obstack.h $(INCDIR)/aout/aout64.h
+DEPOBJ_cris_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-cris.h \
+ $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h $(INCDIR)/aout/aout64.h \
+ $(INCDIR)/obstack.h
+DEPOBJ_cris_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-cris.h \
+ $(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
+ $(INCDIR)/obstack.h subsegs.h
+DEPOBJ_cris_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
+ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
+ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-cris.h subsegs.h \
+ $(INCDIR)/obstack.h $(INCDIR)/aout/aout64.h
DEPOBJ_d10v_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-d10v.h \
$(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
$(INCDIR)/obstack.h subsegs.h
$(DEPOBJ_i386_elf)
DEPOBJ_mips_multi = $(DEPOBJ_mips_coff) $(DEPOBJ_mips_ecoff) \
$(DEPOBJ_mips_elf)
+DEPOBJ_cris_multi = $(DEPOBJ_cris_aout) $(DEPOBJ_cris_elf)
DEP_a29k_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-a29k.h \
$(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h
DEP_a29k_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-a29k.h \
DEP_avr_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
$(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
$(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr.h
+DEP_cris_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-cris.h \
+ $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h
+DEP_cris_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-cris.h \
+ $(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h
+DEP_cris_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
+ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
+ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-cris.h
DEP_d10v_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-d10v.h \
$(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h
DEP_d10v_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
$(DEP_i386_elf)
DEP_mips_multi = $(DEP_mips_coff) $(DEP_mips_ecoff) \
$(DEP_mips_elf)
+DEP_cris_multi = $(DEP_cris_aout) $(DEP_cris_elf)
BMKDEP = #DO NOT PUT ANYTHING BETWEEN THIS LINE AND THE MATCHING WARNING ABOVE.
#MKDEP DO NOT PUT ANYTHING BETWEEN THIS LINE AND THE MATCHING WARNING BELOW.
app.o: app.c
write.o: write.c subsegs.h $(INCDIR)/obstack.h output-file.h
gasp.o: gasp.c sb.h macro.h
itbl-ops.o: itbl-ops.c itbl-ops.h
+e-crisaout.o: $(srcdir)/config/e-crisaout.c emul-target.h
+e-criself.o: $(srcdir)/config/e-criself.c emul-target.h
e-i386aout.o: $(srcdir)/config/e-i386aout.c emul-target.h
e-i386coff.o: $(srcdir)/config/e-i386coff.c emul-target.h
e-i386elf.o: $(srcdir)/config/e-i386elf.c emul-target.h
arc \
arm \
avr \
+ cris \
d10v \
d30v \
fr30 \
case $$o in \
aout) \
case $$c in \
- a29k | arm | i386 | i860 | m68k | mips | ns32k | sparc | tahoe | tic30 | vax) \
+ a29k | arm | cris | i386 | i860 | m68k | mips | ns32k | sparc | tahoe | tic30 | vax) \
valid=yes ;; \
esac ;; \
bout) \
# These are like CPU_TYPES and CPU_OBJ_VALID, for the obj=multi case.
-MULTI_CPU_TYPES = i386 mips
+MULTI_CPU_TYPES = i386 mips cris
MULTI_CPU_OBJ_VALID = \
valid= ; \
case $$o in \
aout) \
case $$c in \
- i386) valid=yes ;; \
+ i386 | cris) valid=yes ;; \
+ esac ;; \
+ coff) \
+ case $$c in \
+ i386 | mips) valid=yes ;; \
esac ;; \
- coff) valid=yes ;; \
ecoff) \
case $$c in \
mips) valid=yes ;; \
config/tc-arc.c \
config/tc-arm.c \
config/tc-avr.c \
+ config/tc-cris.c \
config/tc-d10v.c \
config/tc-d30v.c \
config/tc-fr30.c \
config/tc-arc.h \
config/tc-arm.h \
config/tc-avr.h \
+ config/tc-cris.h \
config/tc-d10v.h \
config/tc-d30v.h \
config/tc-fr30.h \
# Multi files in config
MULTI_CFILES = \
+ config/e-crisaout.c \
+ config/e-criself.c \
config/e-i386aout.c \
config/e-i386coff.c \
config/e-i386elf.c \
$(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr.h subsegs.h \
$(INCDIR)/obstack.h $(INCDIR)/opcode/avr.h
+DEPTC_cris_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-cris.h \
+ $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h subsegs.h $(INCDIR)/obstack.h \
+ $(INCDIR)/opcode/cris.h
+
+DEPTC_cris_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-cris.h \
+ $(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
+ subsegs.h $(INCDIR)/obstack.h $(INCDIR)/opcode/cris.h
+
+DEPTC_cris_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
+ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
+ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-cris.h subsegs.h \
+ $(INCDIR)/obstack.h $(INCDIR)/opcode/cris.h
+
DEPTC_d10v_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-d10v.h \
$(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
subsegs.h $(INCDIR)/obstack.h $(INCDIR)/opcode/d10v.h \
DEPTC_hppa_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-hppa.h \
$(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
- subsegs.h $(INCDIR)/obstack.h $(BFDDIR)/libhppa.h $(BFDDIR)/libbfd.h \
- $(INCDIR)/opcode/hppa.h
+ subsegs.h $(INCDIR)/obstack.h $(BFDDIR)/libhppa.h $(INCDIR)/opcode/hppa.h
DEPTC_hppa_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
$(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
$(INCDIR)/bfdlink.h $(srcdir)/config/tc-hppa.h $(BFDDIR)/elf32-hppa.h \
$(BFDDIR)/libhppa.h $(INCDIR)/elf/hppa.h $(INCDIR)/elf/reloc-macros.h \
- subsegs.h $(INCDIR)/obstack.h $(BFDDIR)/libbfd.h $(INCDIR)/opcode/hppa.h \
+ subsegs.h $(INCDIR)/obstack.h $(INCDIR)/opcode/hppa.h \
dwarf2dbg.h
DEPTC_ia64_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-ia64.h \
DEPTC_mips_multi = $(DEPTC_mips_coff) $(DEPTC_mips_ecoff) \
$(DEPTC_mips_elf)
+DEPTC_cris_multi = $(DEPTC_cris_aout) $(DEPTC_cris_elf)
DEPOBJ_a29k_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-a29k.h \
$(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h $(INCDIR)/aout/aout64.h \
$(INCDIR)/obstack.h
$(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr.h subsegs.h \
$(INCDIR)/obstack.h $(INCDIR)/aout/aout64.h
+DEPOBJ_cris_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-cris.h \
+ $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h $(INCDIR)/aout/aout64.h \
+ $(INCDIR)/obstack.h
+
+DEPOBJ_cris_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-cris.h \
+ $(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
+ $(INCDIR)/obstack.h subsegs.h
+
+DEPOBJ_cris_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
+ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
+ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-cris.h subsegs.h \
+ $(INCDIR)/obstack.h $(INCDIR)/aout/aout64.h
+
DEPOBJ_d10v_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-d10v.h \
$(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h \
$(INCDIR)/obstack.h subsegs.h
DEPOBJ_mips_multi = $(DEPOBJ_mips_coff) $(DEPOBJ_mips_ecoff) \
$(DEPOBJ_mips_elf)
+DEPOBJ_cris_multi = $(DEPOBJ_cris_aout) $(DEPOBJ_cris_elf)
DEP_a29k_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-a29k.h \
$(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h
$(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
$(INCDIR)/bfdlink.h $(srcdir)/config/tc-avr.h
+DEP_cris_aout = $(srcdir)/config/obj-aout.h $(srcdir)/config/tc-cris.h \
+ $(BFDDIR)/libaout.h $(INCDIR)/bfdlink.h
+
+DEP_cris_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-cris.h \
+ $(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h
+
+DEP_cris_elf = $(srcdir)/config/obj-elf.h $(BFDDIR)/elf-bfd.h \
+ $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
+ $(INCDIR)/bfdlink.h $(srcdir)/config/tc-cris.h
+
DEP_d10v_coff = $(srcdir)/config/obj-coff.h $(srcdir)/config/tc-d10v.h \
$(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h $(INCDIR)/bfdlink.h
DEP_mips_multi = $(DEP_mips_coff) $(DEP_mips_ecoff) \
$(DEP_mips_elf)
+DEP_cris_multi = $(DEP_cris_aout) $(DEP_cris_elf)
BMKDEP = #DO NOT PUT ANYTHING BETWEEN THIS LINE AND THE MATCHING WARNING ABOVE.
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
-TAR = gtar
+TAR = tar
GZIP_ENV = --best
SOURCES = $(itbl_test_SOURCES) $(as_new_SOURCES) $(EXTRA_as_new_SOURCES) $(gasp_new_SOURCES)
OBJECTS = $(itbl_test_OBJECTS) $(as_new_OBJECTS) $(gasp_new_OBJECTS)
$(COMPILE) -c $(srcdir)/config/e-i386coff.c
e-i386elf.o: $(srcdir)/config/e-i386elf.c
$(COMPILE) -c $(srcdir)/config/e-i386elf.c
+e-crisaout.o: $(srcdir)/config/e-crisaout.c
+ $(COMPILE) -c $(srcdir)/config/e-crisaout.c
+e-criself.o: $(srcdir)/config/e-criself.c
+ $(COMPILE) -c $(srcdir)/config/e-criself.c
# If m68k-parse.y is in a different directory, then ylwrap will use an
# absolute path when it invokes yacc, which will cause yacc to put the
write.o: write.c subsegs.h $(INCDIR)/obstack.h output-file.h
gasp.o: gasp.c sb.h macro.h
itbl-ops.o: itbl-ops.c itbl-ops.h
+e-crisaout.o: $(srcdir)/config/e-crisaout.c emul-target.h
+e-criself.o: $(srcdir)/config/e-criself.c emul-target.h
e-i386aout.o: $(srcdir)/config/e-i386aout.c emul-target.h
e-i386coff.o: $(srcdir)/config/e-i386coff.c emul-target.h
e-i386elf.o: $(srcdir)/config/e-i386elf.c emul-target.h
LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \
DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \
${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
-$libtool_flags --no-verify $ac_aux_dir/ltmain.sh $host \
+$libtool_flags --no-verify $ac_aux_dir/ltmain.sh $lt_target \
|| AC_MSG_ERROR([libtool configure failed])
# Reload cache, that may have been modified by ltconfig
AC_REQUIRE([AC_PROG_LN_S])dnl
dnl
+case "$target" in
+NONE) lt_target="$host" ;;
+*) lt_target="$target" ;;
+esac
+
# Check for any special flags to pass to ltconfig.
libtool_flags="--cache-file=$cache_file"
test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
# Some flags need to be propagated to the compiler or linker for good
# libtool support.
-case "$host" in
+case "$lt_target" in
*-*-irix6*)
# Find out which ABI we are using.
echo '[#]line __oline__ "configure"' > conftest.$ac_ext
AC_DEFUN(AC_CHECK_LIBM,
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
LIBM=
-case "$host" in
+case "$lt_target" in
*-*-beos* | *-*-cygwin*)
# These system don't have libm
;;
extern struct emulation mipsbelf, mipslelf, mipself;
extern struct emulation mipsbecoff, mipslecoff, mipsecoff;
extern struct emulation i386coff, i386elf, i386aout;
+extern struct emulation crisaout, criself;
static struct emulation *const emulations[] = { EMULATIONS };
static const int n_emulations = sizeof (emulations) / sizeof (emulations[0]);
--- /dev/null
+#include "as.h"
+#include "emul.h"
+
+static const char *
+crisaout_bfd_name ()
+{
+ abort ();
+ return NULL;
+}
+
+#define emul_bfd_name crisaout_bfd_name
+#define emul_format &aout_format_ops
+
+#define emul_name "crisaout"
+#define emul_struct_name crisaout
+#define emul_default_endian 0
+#include "emul-target.h"
--- /dev/null
+#include "as.h"
+#include "emul.h"
+
+static const char *
+criself_bfd_name ()
+{
+ abort ();
+ return NULL;
+}
+
+#define emul_bfd_name criself_bfd_name
+#define emul_format &elf_format_ops
+
+#define emul_name "criself"
+#define emul_struct_name criself
+#define emul_default_endian 0
+#include "emul-target.h"
--- /dev/null
+/* tc-cris.c -- Assembler code for the CRIS CPU core.
+ Copyright (C) 2000 Free Software Foundation, Inc.
+
+ Contributed by Axis Communications AB, Lund, Sweden.
+ Originally written for GAS 1.38.1 by Mikael Asker.
+ Updated, BFDized and GNUified by Hans-Peter Nilsson.
+
+ 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 <stdio.h>
+#include <ctype.h>
+#include "as.h"
+#include "subsegs.h"
+#include "opcode/cris.h"
+
+/* Conventions used here:
+ Generally speaking, pointers to binutils types such as "fragS" and
+ "expressionS" get parameter and variable names ending in "P", such as
+ "fragP", to harmonize with the rest of the binutils code. Other
+ pointers get a "p" suffix, such as "bufp". Any function or type-name
+ that could clash with a current or future binutils or GAS function get
+ a "cris_" prefix. */
+
+/* This might be CRIS_INSN_NONE if we're assembling a prefix-insn only.
+ Note that some prefix-insns might be assembled as CRIS_INSN_NORMAL. */
+enum cris_insn_kind
+{
+ CRIS_INSN_NORMAL, CRIS_INSN_NONE, CRIS_INSN_BRANCH
+};
+
+/* An instruction will have one of these prefixes.
+ Although the same bit-pattern, we handle BDAP with an immediate
+ expression (eventually quick or [pc+]) different from when we only have
+ register expressions. */
+enum prefix_kind
+{
+ PREFIX_NONE, PREFIX_BDAP_IMM, PREFIX_BDAP, PREFIX_BIAP, PREFIX_DIP,
+ PREFIX_PUSH
+};
+
+/* The prefix for an instruction. */
+struct cris_prefix
+{
+ enum prefix_kind kind;
+ int base_reg_number;
+ unsigned int opcode;
+
+ /* There might be an expression to be evaluated, like I in [rN+I]. */
+ expressionS expr;
+
+ /* If there's an expression, we might need a relocation. Here's the
+ type of what relocation to start relaxaton with.
+ The relocation is assumed to start immediately after the prefix insn,
+ so we don't provide an offset. */
+ enum bfd_reloc_code_real reloc;
+};
+
+/* The description of the instruction being assembled. */
+struct cris_instruction
+{
+ /* If CRIS_INSN_NONE, then this insn is of zero length. */
+ enum cris_insn_kind insn_type;
+
+ /* If a special register was mentioned, this is its description, else
+ it is NULL. */
+ const struct cris_spec_reg *spec_reg;
+
+ unsigned int opcode;
+
+ /* An insn may have at most one expression; theoretically there could be
+ another in its prefix (but I don't see how that could happen). */
+ expressionS expr;
+
+ /* The expression might need a relocation. Here's one to start
+ relaxation with. */
+ enum bfd_reloc_code_real reloc;
+
+ /* The size in bytes of an immediate expression, or zero in
+ nonapplicable. */
+ int imm_oprnd_size;
+};
+
+static void cris_process_instruction PARAMS ((char *,
+ struct cris_instruction *,
+ struct cris_prefix *));
+static int get_bwd_size_modifier PARAMS ((char **, int *));
+static int get_bw_size_modifier PARAMS ((char **, int *));
+static int get_gen_reg PARAMS ((char **, int *));
+static int get_spec_reg PARAMS ((char **,
+ const struct cris_spec_reg **));
+static int get_autoinc_prefix_or_indir_op PARAMS ((char **,
+ struct cris_prefix *,
+ int *, int *, int *,
+ expressionS *));
+static int get_3op_or_dip_prefix_op PARAMS ((char **,
+ struct cris_prefix *));
+static int cris_get_expression PARAMS ((char **, expressionS *));
+static int get_flags PARAMS ((char **, int *));
+static void gen_bdap PARAMS ((int, expressionS *));
+static int branch_disp PARAMS ((int));
+static void gen_cond_branch_32 PARAMS ((char *, char *, fragS *,
+ symbolS *, symbolS *, long int));
+static void cris_number_to_imm PARAMS ((char *, long, int, fixS *));
+static void cris_create_short_jump PARAMS ((char *, addressT, addressT,
+ fragS *, symbolS *));
+/* Handle to the opcode hash table. */
+static struct hash_control *op_hash = NULL;
+
+const pseudo_typeS md_pseudo_table[] =
+{
+ {"dword", cons, 4},
+ {NULL, 0, 0}
+};
+
+static int warn_for_branch_expansion = 0;
+
+const char cris_comment_chars[] = ";";
+
+/* This array holds the chars that only start a comment at the beginning of
+ a line. If the line seems to have the form '# 123 filename'
+ .line and .file directives will appear in the pre-processed output */
+/* Note that input_file.c hand-checks for '#' at the beginning of the
+ first line of the input file. This is because the compiler outputs
+ #NO_APP at the beginning of its output. */
+/* Also note that slash-star will always start a comment */
+const char line_comment_chars[] = "#";
+const char line_separator_chars[] = "@";
+
+/* Now all floating point support is shut off. See md_atof. */
+const char EXP_CHARS[] = "";
+const char FLT_CHARS[] = "";
+
+
+/* For CRIS, we encode the relax_substateTs (in e.g. fr_substate) as:
+ 2 1 0
+ ---/ /--+-----------------+-----------------+-----------------+
+ | what state ? | how long ? |
+ ---/ /--+-----------------+-----------------+-----------------+
+
+ The "how long" bits are 00 = byte, 01 = word, 10 = dword (long).
+ This is a Un*x convention.
+ Not all lengths are legit for a given value of (what state).
+
+ Groups for CRIS address relaxing:
+
+ 1. Bcc
+ length: byte, word, 10-byte expansion
+
+ 2. BDAP
+ length: byte, word, dword */
+
+#define STATE_CONDITIONAL_BRANCH (1)
+#define STATE_BASE_PLUS_DISP_PREFIX (2)
+
+#define STATE_LENGTH_MASK (3)
+#define STATE_BYTE (0)
+#define STATE_WORD (1)
+#define STATE_DWORD (2)
+/* Symbol undefined. */
+#define STATE_UNDF (3)
+#define STATE_MAX_LENGTH (3)
+
+
+/* These displacements are relative to the adress following the opcode
+ word of the instruction. The first letter is Byte, Word. The 2nd
+ letter is Forward, Backward. */
+
+#define BRANCH_BF ( 254)
+#define BRANCH_BB (-256)
+#define BRANCH_WF (2+ 32767)
+#define BRANCH_WB (2+-32768)
+
+#define BDAP_BF ( 127)
+#define BDAP_BB (-128)
+#define BDAP_WF ( 32767)
+#define BDAP_WB (-32768)
+
+#define ENCODE_RELAX(what, length) (((what) << 2) + (length))
+
+const relax_typeS md_cris_relax_table[] =
+{
+ /* Error sentinel (0, 0). */
+ {1, 1, 0, 0},
+
+ /* Unused (0, 1). */
+ {1, 1, 0, 0},
+
+ /* Unused (0, 2). */
+ {1, 1, 0, 0},
+
+ /* Unused (0, 3). */
+ {1, 1, 0, 0},
+
+ /* Bcc o (1, 0). */
+ {BRANCH_BF, BRANCH_BB, 0, ENCODE_RELAX (1, 1)},
+
+ /* Bcc [PC+] (1, 1). */
+ {BRANCH_WF, BRANCH_WB, 2, ENCODE_RELAX (1, 2)},
+
+ /* BEXT/BWF, BA, JUMP (external), JUMP (always), Bnot_cc, JUMP (default)
+ (1, 2). */
+ {0, 0, 10, 0},
+
+ /* Unused (1, 3). */
+ {1, 1, 0, 0},
+
+ /* BDAP o (2, 0). */
+ {BDAP_BF, BDAP_BB, 0, ENCODE_RELAX (2, 1)},
+
+ /* BDAP.[bw] [PC+] (2, 1). */
+ {BDAP_WF, BDAP_WB, 2, ENCODE_RELAX (2, 2)},
+
+ /* BDAP.d [PC+] (2, 2). */
+ {0, 0, 4, 0}
+};
+
+#undef BRANCH_BF
+#undef BRANCH_BB
+#undef BRANCH_WF
+#undef BRANCH_WB
+#undef BDAP_BF
+#undef BDAP_BB
+#undef BDAP_WF
+#undef BDAP_WB
+
+
+/* Target-specific multicharacter options, not const-declared at usage
+ in 2.9.1 and CVS of 2000-02-16. */
+struct option md_longopts[] =
+{
+ {NULL, no_argument, NULL, 0}
+};
+
+/* Not const-declared at usage in 2.9.1. */
+size_t md_longopts_size = sizeof (md_longopts);
+const char *md_shortopts = "hHN";
+
+
+/* At first glance, this may seems wrong and should be 4 (ba + nop); but
+ since a short_jump must skip a *number* of long jumps, it must also be
+ a long jump. Here, we hope to make it a "ba [16bit_offs]" and a "nop"
+ for the delay slot and hope that the jump table at most needs
+ 32767/4=8191 long-jumps. A branch is better than a jump, since it is
+ relative; we will not have a reloc to fix up somewhere.
+
+ Note that we can't add relocs, because relaxation uses these fixed
+ numbers, and md_create_short_jump is called after relaxation. */
+
+const int md_short_jump_size = 6;
+const int md_long_jump_size = 6;
+
+
+/* Report output format. */
+const char *
+cris_target_format ()
+{
+ switch (OUTPUT_FLAVOR)
+ {
+ case bfd_target_aout_flavour:
+ return "a.out-cris";
+
+ case bfd_target_elf_flavour:
+ return "elf32-cris";
+
+ default:
+ abort ();
+ return NULL;
+ }
+}
+
+/* Prepare machine-dependent frags for relaxation.
+
+ Called just before relaxation starts. Any symbol that is now undefined
+ will not become defined.
+
+ Return the correct fr_subtype in the frag.
+
+ Return the initial "guess for fr_var" to caller. The guess for fr_var
+ is *actually* the growth beyond fr_fix. Whatever we do to grow fr_fix
+ or fr_var contributes to our returned value.
+
+ Although it may not be explicit in the frag, pretend
+ fr_var starts with a value. */
+
+int
+md_estimate_size_before_relax (fragP, segment_type)
+ fragS *fragP;
+ /* The segment is either N_DATA or N_TEXT. */
+ segT segment_type;
+{
+ int old_fr_fix;
+
+ old_fr_fix = fragP->fr_fix;
+
+ switch (fragP->fr_subtype)
+ {
+ case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_UNDF):
+ if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
+ {
+ /* The symbol lies in the same segment - a relaxable case. */
+ fragP->fr_subtype
+ = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
+ }
+ else
+ {
+ /* Unknown or not the same segment, so not relaxable. */
+ char *writep;
+
+ /* A small branch-always (2 bytes) to the "real" branch
+ instruction, plus a delay-slot nop (2 bytes), plus a
+ jump (2 plus 4 bytes). See gen_cond_branch_32. */
+ fragP->fr_fix += 2 + 2 + 2 + 4;
+ writep = fragP->fr_literal + old_fr_fix;
+ gen_cond_branch_32 (fragP->fr_opcode, writep, fragP,
+ fragP->fr_symbol, (symbolS *)NULL,
+ fragP->fr_offset);
+ frag_wane (fragP);
+ }
+ break;
+
+ case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE):
+ case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD):
+ /* We *might* give a better initial guess if we peek at offsets
+ now, but the caller will relax correctly and without this, so
+ don't bother. */
+ break;
+
+ case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX, STATE_UNDF):
+ /* Note that we can not do anything sane with relaxing
+ [rX + a_known_symbol_in_text], it will have to be a 32-bit
+ value.
+
+ We could play tricks with managing a constant pool and make
+ a_known_symbol_in_text a "bdap [pc + offset]" pointing there, but
+ that's pointless, it can only be longer and slower.
+
+ Off-topic: If PIC becomes *really* important, and has to be done
+ in the assembler and linker only (which would be weird or
+ clueless), we can so something. Imagine:
+ move.x [r + 32_bit_symbol],r
+ move.x [32_bit_symbol],r
+ move.x 32_bit_symbol,r
+ can be shortened by a word (8-bit offset) if we are close to the
+ symbol or keep its length (16-bit offset) or be a word longer
+ (32-bit offset). Then change the 32_bit_symbol into a "bdap [pc
+ + offset]", and put the offset to the 32_bit_symbol in "offset".
+ Weird, to say the least, and we still have to add support for a
+ PC-relative relocation in the loader (shared libraries). But
+ it's an interesting thought. */
+
+ if (S_GET_SEGMENT (fragP->fr_symbol) != absolute_section)
+ {
+ /* Go for dword if not absolute or same segment. */
+ fragP->fr_subtype
+ = ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX, STATE_DWORD);
+ fragP->fr_var += 4;
+ }
+ else
+ {
+ /* Absolute expression. */
+ long int value;
+ value = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
+
+ if (value >= -128 && value <= 127)
+ {
+ /* Byte displacement. */
+ (fragP->fr_opcode)[0] = value;
+ }
+ else
+ {
+ /* Word or dword displacement. */
+ int pow2_of_size = 1;
+ char *writep;
+
+ if (value < -32768 || value > 32767)
+ {
+ /* Outside word range, make it a dword. */
+ pow2_of_size = 2;
+ }
+
+ /* Modify the byte-offset BDAP into a word or dword offset
+ BDAP. Or really, a BDAP rX,8bit into a
+ BDAP.[wd] rX,[PC+] followed by a and a word or dword. */
+ (fragP->fr_opcode)[0] = BDAP_PC_LOW + pow2_of_size * 16;
+
+ /* Keep the register number in the highest four bits. */
+ (fragP->fr_opcode)[1] &= 0xF0;
+ (fragP->fr_opcode)[1] |= BDAP_INCR_HIGH;
+
+ /* It grew by two or four bytes. */
+ fragP->fr_fix += 1 << pow2_of_size;
+ writep = fragP->fr_literal + old_fr_fix;
+ md_number_to_chars (writep, value, 1 << pow2_of_size);
+ }
+ frag_wane (fragP);
+ }
+ break;
+
+ default:
+ BAD_CASE (fragP->fr_subtype);
+ }
+
+ return fragP->fr_var + (fragP->fr_fix - old_fr_fix);
+}
+
+
+/* Perform post-processing of machine-dependent frags after relaxation.
+ Called after relaxation is finished.
+ In: Address of frag.
+ fr_type == rs_machine_dependent.
+ fr_subtype is what the address relaxed to.
+
+ Out: Any fixS:s and constants are set up.
+
+ The caller will turn the frag into a ".space 0". */
+
+void
+md_convert_frag (abfd, sec, fragP)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ segT sec ATTRIBUTE_UNUSED;
+ fragS *fragP;
+{
+ /* Pointer to first byte in variable-sized part of the frag. */
+ char *var_partp;
+
+ /* Pointer to first opcode byte in frag. */
+ char *opcodep;
+
+ /* Used to check integrity of the relaxation.
+ One of 2 = long, 1 = word, or 0 = byte. */
+ int length_code;
+
+ /* Size in bytes of variable-sized part of frag. */
+ int var_part_size = 0;
+
+ /* This is part of *fragP. It contains all information about addresses
+ and offsets to varying parts. */
+ symbolS *symbolP;
+ unsigned long var_part_offset;
+
+ /* Where, in file space, is _var of *fragP? */
+ unsigned long address_of_var_part = 0;
+
+ /* Where, in file space, does addr point? */
+ unsigned long target_address;
+
+ know (fragP->fr_type == rs_machine_dependent);
+
+ length_code = fragP->fr_subtype & STATE_LENGTH_MASK;
+ know (length_code >= 0 && length_code < STATE_MAX_LENGTH);
+
+ var_part_offset = fragP->fr_fix;
+ var_partp = fragP->fr_literal + var_part_offset;
+ opcodep = fragP->fr_opcode;
+
+ symbolP = fragP->fr_symbol;
+ target_address
+ = (symbolP
+ ? S_GET_VALUE (symbolP) + symbol_get_frag(fragP->fr_symbol)->fr_address
+ : 0 ) + fragP->fr_offset;
+ address_of_var_part = fragP->fr_address + var_part_offset;
+
+ switch (fragP->fr_subtype)
+ {
+ case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE):
+ opcodep[0] = branch_disp ((target_address - address_of_var_part));
+ var_part_size = 0;
+ break;
+
+ case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD):
+ /* We had a quick immediate branch, now turn it into a word one i.e. a
+ PC autoincrement. */
+ opcodep[0] = BRANCH_PC_LOW;
+ opcodep[1] &= 0xF0;
+ opcodep[1] |= BRANCH_INCR_HIGH;
+ md_number_to_chars (var_partp,
+ (long) (target_address - (address_of_var_part + 2)),
+ 2);
+ var_part_size = 2;
+ break;
+
+ case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_DWORD):
+ gen_cond_branch_32 (fragP->fr_opcode, var_partp, fragP,
+ fragP->fr_symbol, (symbolS *)NULL,
+ fragP->fr_offset);
+ /* Ten bytes added: a branch, nop and a jump. */
+ var_part_size = 2 + 2 + 4 + 2;
+ break;
+
+ case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX, STATE_BYTE):
+ var_partp[0] = target_address - (address_of_var_part + 1);
+ var_part_size = 0;
+ break;
+
+ case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX, STATE_WORD):
+ /* We had a BDAP 8-bit "quick immediate", now turn it into a 16-bit
+ one that uses PC autoincrement. */
+ opcodep[0] = BDAP_PC_LOW + (1 << 4);
+ opcodep[1] &= 0xF0;
+ opcodep[1] |= BDAP_INCR_HIGH;
+ md_number_to_chars (var_partp, (long)(target_address), 2);
+ var_part_size = 2;
+ break;
+
+ case ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX, STATE_DWORD):
+ /* We had a BDAP 16-bit "word", change the offset to a dword. */
+ opcodep[0] = BDAP_PC_LOW + (2 << 4);
+ opcodep[1] &= 0xF0;
+ opcodep[1] |= BDAP_INCR_HIGH;
+ if (fragP->fr_symbol == NULL)
+ md_number_to_chars (var_partp, fragP->fr_offset, 4);
+ else
+ fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
+ fragP->fr_offset, 0, BFD_RELOC_32);
+ var_part_size = 4;
+ break;
+
+ default:
+ BAD_CASE (fragP->fr_subtype);
+ break;
+ }
+
+ fragP->fr_fix += var_part_size;
+
+}
+
+/* Generate a short jump around a secondary jump table.
+ Used by md_create_long_jump.
+
+ This used to be md_create_short_jump, but is now called from
+ md_create_long_jump instead, when sufficient.
+ since the sizes of the jumps are the same. It used to be brittle,
+ making possibilities for creating bad code. */
+
+static void
+cris_create_short_jump (storep, from_addr, to_addr, fragP, to_symbol)
+ char *storep;
+ addressT from_addr;
+ addressT to_addr;
+ fragS *fragP ATTRIBUTE_UNUSED;
+ symbolS *to_symbol ATTRIBUTE_UNUSED;
+{
+ long int distance;
+
+ distance = to_addr - from_addr;
+
+ if (-254 <= distance && distance <= 256)
+ {
+ /* Create a "short" short jump: "BA distance - 2". */
+ storep[0] = branch_disp (distance-2);
+ storep[1] = BA_QUICK_HIGH;
+
+ /* A nop for the delay slot. */
+ md_number_to_chars (storep+2, NOP_OPCODE, 2);
+
+ /* The extra word should be filled with something sane too. Make it
+ a nop to keep disassembly sane. */
+ md_number_to_chars (storep+4, NOP_OPCODE, 2);
+ }
+ else
+ {
+ /* Make it a "long" short jump: "BA (PC+)". */
+ md_number_to_chars (storep, BA_PC_INCR_OPCODE, 2);
+
+ /* ".WORD distance - 4". */
+ md_number_to_chars (storep + 2, (long) (distance - 4), 2);
+
+ /* A nop for the delay slot. */
+ md_number_to_chars (storep+4, NOP_OPCODE, 2);
+ }
+}
+
+
+/* Generate a long jump in a secondary jump table.
+
+ storep Where to store the jump instruction.
+ from_addr Address of the jump instruction.
+ to_addr Destination address of the jump.
+ fragP Which frag the destination address operand
+ lies in.
+ to_symbol Destination symbol. */
+
+void
+md_create_long_jump (storep, from_addr, to_addr, fragP, to_symbol)
+ char *storep;
+ addressT from_addr;
+ addressT to_addr;
+ fragS *fragP;
+ symbolS *to_symbol;
+{
+ long int distance;
+
+ distance = to_addr - from_addr;
+
+ if (-32763 <= distance && distance <= 32772)
+ {
+ /* Then make it a "short" long jump. */
+ cris_create_short_jump (storep, from_addr, to_addr, fragP,
+ to_symbol);
+ }
+ else
+ {
+ /* We have a "long" long jump: "JUMP (PC+)". */
+ md_number_to_chars (storep, JUMP_PC_INCR_OPCODE, 2);
+
+ /* Follow with a ".DWORD to_addr". */
+ fix_new (fragP, storep + 2 - fragP->fr_literal, 4, to_symbol,
+ 0, 0, BFD_RELOC_32);
+ }
+}
+
+
+/* Port-specific assembler initialization. */
+void
+md_begin ()
+{
+ const char *hashret = NULL;
+ int i = 0;
+
+ /* Set up a hash table for the instructions. */
+ op_hash = hash_new ();
+ if (op_hash == NULL)
+ as_fatal (_("Virtual memory exhausted"));
+
+ while (cris_opcodes[i].name != NULL)
+ {
+ const char *name = cris_opcodes[i].name;
+ hashret = hash_insert (op_hash, name, (PTR) &cris_opcodes[i]);
+
+ if (hashret != NULL && *hashret != '\0')
+ as_fatal (_("Can't hash `%s': %s\n"), cris_opcodes[i].name,
+ *hashret == 0 ? _("(unknown reason)") : hashret);
+ do
+ {
+ if (cris_opcodes[i].match & cris_opcodes[i].lose)
+ as_fatal (_("Buggy opcode: `%s' \"%s\"\n"), cris_opcodes[i].name,
+ cris_opcodes[i].args);
+
+ ++i;
+ } while (cris_opcodes[i].name != NULL
+ && strcmp (cris_opcodes[i].name, name) == 0);
+ }
+}
+
+
+/* Assemble a source line. */
+void
+md_assemble (str)
+ char *str;
+{
+ struct cris_instruction output_instruction;
+ struct cris_prefix prefix;
+ char *opcodep;
+ char *p;
+
+ know (str);
+
+ /* Do the low-level grunt - assemble to bits and split up into a prefix
+ and ordinary insn. */
+ cris_process_instruction (str, &output_instruction, &prefix);
+
+ /* Handle any prefixes to the instruction. */
+ switch (prefix.kind)
+ {
+ case PREFIX_NONE:
+ break;
+
+ /* When the expression is unknown for a BDAP, it can need 0, 2 or 4
+ extra bytes, so we handle it separately. */
+ case PREFIX_BDAP_IMM:
+ gen_bdap (prefix.base_reg_number, &prefix.expr);
+ break;
+
+ case PREFIX_BDAP:
+ case PREFIX_BIAP:
+ case PREFIX_DIP:
+ opcodep = frag_more (2);
+
+ /* Output the prefix opcode. */
+ md_number_to_chars (opcodep, (long) prefix.opcode, 2);
+
+ /* This only happens for DIP, but is ok for the others as they have
+ no reloc. */
+ if (prefix.reloc != BFD_RELOC_NONE)
+ {
+ /* Output an absolute mode address. */
+ p = frag_more (4);
+ fix_new_exp (frag_now, (p - frag_now->fr_literal), 4,
+ &prefix.expr, 0, prefix.reloc);
+ }
+ break;
+
+ case PREFIX_PUSH:
+ opcodep = frag_more (2);
+
+ /* Output the prefix opcode. Being a "push", we add the negative
+ size of the register to "sp". */
+ if (output_instruction.spec_reg != NULL)
+ {
+ /* Special register. */
+ opcodep[0] = -output_instruction.spec_reg->reg_size;
+ }
+ else
+ {
+ /* General register. */
+ opcodep[0] = -4;
+ }
+ opcodep[1] = (REG_SP << 4) + (BDAP_QUICK_OPCODE >> 8);
+ break;
+
+ default:
+ BAD_CASE (prefix.kind);
+ }
+
+ /* If we only had a prefix insn, we're done. */
+ if (output_instruction.insn_type == CRIS_INSN_NONE)
+ return;
+
+ /* Done with the prefix. Continue with the main instruction. */
+ opcodep = frag_more (2);
+
+ /* Output the instruction opcode. */
+ md_number_to_chars (opcodep, (long)(output_instruction.opcode), 2);
+
+ /* Output the symbol-dependent instruction stuff. */
+ if (output_instruction.insn_type == CRIS_INSN_BRANCH)
+ {
+ segT to_seg = absolute_section;
+ int is_undefined = 0;
+ int length_code;
+
+ if (output_instruction.expr.X_op != O_constant)
+ {
+ to_seg = S_GET_SEGMENT (output_instruction.expr.X_add_symbol);
+
+ if (to_seg == undefined_section)
+ is_undefined = 1;
+ }
+
+ if (output_instruction.expr.X_op == O_constant
+ || to_seg == now_seg || is_undefined)
+ {
+ /* If is_undefined, then the expression may BECOME now_seg. */
+ length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
+
+ /* Make room for max ten bytes of variable length. */
+ frag_var (rs_machine_dependent, 10, 0,
+ ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
+ output_instruction.expr.X_add_symbol,
+ output_instruction.expr.X_add_number,
+ opcodep);
+ }
+ else
+ {
+ /* We have: to_seg != now_seg && to_seg != undefined_section.
+ This means it is a branch to a known symbol in another
+ section. Code in data? Weird but valid. Emit a 32-bit
+ branch. */
+ gen_cond_branch_32 (opcodep, frag_more (10), frag_now,
+ output_instruction.expr.X_add_symbol,
+ (symbolS *)NULL,
+ output_instruction.expr.X_add_number);
+ }
+ }
+ else
+ {
+ if (output_instruction.imm_oprnd_size > 0)
+ {
+ /* The intruction has an immediate operand. */
+ enum bfd_reloc_code_real reloc = 0;
+
+ switch (output_instruction.imm_oprnd_size)
+ {
+ /* Any byte-size immediate constants are treated as
+ word-size. FIXME: Thus overflow check does not work
+ correctly. */
+
+ case 2:
+ reloc = BFD_RELOC_16;
+ break;
+
+ case 4:
+ reloc = BFD_RELOC_32;
+ break;
+
+ default:
+ BAD_CASE (output_instruction.imm_oprnd_size);
+ }
+
+ p = frag_more (output_instruction.imm_oprnd_size);
+ fix_new_exp (frag_now, (p - frag_now->fr_literal),
+ output_instruction.imm_oprnd_size,
+ &output_instruction.expr, 0, reloc);
+ }
+ else if (output_instruction.reloc != BFD_RELOC_NONE)
+ {
+ /* An immediate operand that has a relocation and needs to be
+ processed further. */
+
+ /* It is important to use fix_new_exp here and everywhere else
+ (and not fix_new), as fix_new_exp can handle "difference
+ expressions" - where the expression contains a difference of
+ two symbols in the same segment. */
+ fix_new_exp (frag_now, (opcodep - frag_now->fr_literal), 2,
+ &output_instruction.expr, 0,
+ output_instruction.reloc);
+ }
+ }
+}
+
+
+/* Low level text-to-bits assembly. */
+static void
+cris_process_instruction (insn_text, out_insnp, prefixp)
+ char *insn_text;
+ struct cris_instruction *out_insnp;
+ struct cris_prefix *prefixp;
+{
+ char *s;
+ char modified_char = 0;
+ const char *args;
+ struct cris_opcode *instruction;
+ char *operands;
+ int match = 0;
+ int mode;
+ int regno;
+ int size_bits;
+
+ /* Reset these fields to a harmless state in case we need to return in
+ error. */
+ prefixp->kind = PREFIX_NONE;
+ prefixp->reloc = BFD_RELOC_NONE;
+ out_insnp->insn_type = CRIS_INSN_NORMAL;
+ out_insnp->imm_oprnd_size = 0;
+
+ /* Find the end of the opcode mnemonic. We assume (true in 2.9.1)
+ that the caller has translated the opcode to lower-case, up to the
+ first non-letter. */
+ for (operands = insn_text;
+ islower (*operands);
+ ++operands)
+ ;
+
+ /* Terminate the opcode after letters, but save the character there if
+ it was of significance. */
+ switch (*operands)
+ {
+ case '\0':
+ break;
+
+ case '.':
+ /* Put back the modified character later */
+ modified_char = *operands;
+ /* FALLTHROUGH. */
+
+ case ' ':
+ /* Consume the character after the mnemonic and replace */
+ /* it with '\0'. */
+ *operands++ = '\0';
+ break;
+
+ default:
+ as_bad (_("Unknown opcode: `%s'"), insn_text);
+ return;
+ }
+
+ /* Find the instruction. */
+ instruction = (struct cris_opcode *) hash_find (op_hash, insn_text);
+ if (instruction == NULL)
+ {
+ as_bad (_("Unknown opcode: `%s'"), insn_text);
+ return;
+ }
+
+ /* Put back the modified character. */
+ switch (modified_char)
+ {
+ case 0:
+ break;
+
+ default:
+ *--operands = modified_char;
+ }
+
+
+ /* Try to match an opcode table slot. */
+ for (s = operands;
+ ;
+ )
+ {
+ int imm_expr_found;
+
+ /* Initialize *prefixp, perhaps after being modified for a
+ "near match". */
+ prefixp->kind = PREFIX_NONE;
+ prefixp->reloc = BFD_RELOC_NONE;
+
+ /* Initialize *out_insnp. */
+ memset (out_insnp, 0, sizeof (*out_insnp));
+ out_insnp->opcode = instruction->match;
+ out_insnp->reloc = BFD_RELOC_NONE;
+ out_insnp->insn_type = CRIS_INSN_NORMAL;
+ out_insnp->imm_oprnd_size = 0;
+
+ imm_expr_found = 0;
+
+ /* Build the opcode, checking as we go to make sure that the
+ operands match. */
+ for (args = instruction->args;
+ ;
+ ++args)
+ {
+ switch (*args)
+ {
+ case '\0':
+ /* If we've come to the end of arguments, we're done. */
+ if (*s == '\0')
+ match = 1;
+ break;
+
+ case '!':
+ /* Non-matcher character for disassembly.
+ Ignore it here. */
+ continue;
+
+ case ',':
+ case ' ':
+ /* These must match exactly. */
+ if (*s++ == *args)
+ continue;
+ break;
+
+ case 'B':
+ /* This is not really an operand, but causes a "BDAP
+ -size,SP" prefix to be output, for PUSH instructions. */
+ prefixp->kind = PREFIX_PUSH;
+ continue;
+
+ case 'b':
+ /* This letter marks an operand that should not be matched
+ in the assembler. It is a branch with 16-bit
+ displacement. The assembler will create them from the
+ 8-bit flavor when necessary. The assembler does not
+ support the [rN+] operand, as the [r15+] that is
+ generated for 16-bit displacements. */
+ break;
+
+ case 'c':
+ /* A 5-bit unsigned immediate in bits <4:0>. */
+ if (! cris_get_expression (&s, &out_insnp->expr))
+ break;
+ else
+ {
+ if (out_insnp->expr.X_op == O_constant
+ && (out_insnp->expr.X_add_number < 0
+ || out_insnp->expr.X_add_number > 31))
+ as_bad (_("Immediate value not in 5 bit unsigned range: %ld"),
+ out_insnp->expr.X_add_number);
+
+ out_insnp->reloc = BFD_RELOC_CRIS_UNSIGNED_5;
+ continue;
+ }
+
+ case 'C':
+ /* A 4-bit unsigned immediate in bits <3:0>. */
+ if (! cris_get_expression (&s, &out_insnp->expr))
+ break;
+ else
+ {
+ if (out_insnp->expr.X_op == O_constant
+ && (out_insnp->expr.X_add_number < 0
+ || out_insnp->expr.X_add_number > 15))
+ as_bad (_("Immediate value not in 4 bit unsigned range: %ld"),
+ out_insnp->expr.X_add_number);
+
+ out_insnp->reloc = BFD_RELOC_CRIS_UNSIGNED_4;
+ continue;
+ }
+
+ case 'D':
+ /* General register in bits <15:12> and <3:0>. */
+ if (! get_gen_reg (&s, ®no))
+ break;
+ else
+ {
+ out_insnp->opcode |= regno /* << 0 */;
+ out_insnp->opcode |= regno << 12;
+ continue;
+ }
+
+ case 'f':
+ /* Flags from the condition code register. */
+ {
+ int flags = 0;
+
+ if (! get_flags (&s, &flags))
+ break;
+
+ out_insnp->opcode
+ |= ((flags & 0xf0) << 8) | (flags & 0xf);
+ continue;
+ }
+
+ case 'i':
+ /* A 6-bit signed immediate in bits <5:0>. */
+ if (! cris_get_expression (&s, &out_insnp->expr))
+ break;
+ else
+ {
+ if (out_insnp->expr.X_op == O_constant
+ && (out_insnp->expr.X_add_number < -32
+ || out_insnp->expr.X_add_number > 31))
+ as_bad (_("Immediate value not in 6 bit range: %ld"),
+ out_insnp->expr.X_add_number);
+ out_insnp->reloc = BFD_RELOC_CRIS_SIGNED_6;
+ continue;
+ }
+
+ case 'I':
+ /* A 6-bit unsigned immediate in bits <5:0>. */
+ if (! cris_get_expression (&s, &out_insnp->expr))
+ break;
+ else
+ {
+ if (out_insnp->expr.X_op == O_constant
+ && (out_insnp->expr.X_add_number < 0
+ || out_insnp->expr.X_add_number > 63))
+ as_bad (_("Immediate value not in 6 bit unsigned range: %ld"),
+ out_insnp->expr.X_add_number);
+ out_insnp->reloc = BFD_RELOC_CRIS_UNSIGNED_6;
+ continue;
+ }
+
+ case 'M':
+ /* A size modifier, B, W or D, to be put in a bit position
+ suitable for CLEAR instructions (i.e. reflecting a zero
+ register). */
+ if (! get_bwd_size_modifier (&s, &size_bits))
+ break;
+ else
+ {
+ switch (size_bits)
+ {
+ case 0:
+ out_insnp->opcode |= 0 << 12;
+ break;
+
+ case 1:
+ out_insnp->opcode |= 4 << 12;
+ break;
+
+ case 2:
+ out_insnp->opcode |= 8 << 12;
+ break;
+ }
+ continue;
+ }
+
+ case 'm':
+ /* A size modifier, B, W or D, to be put in bits <5:4>. */
+ if (! get_bwd_size_modifier (&s, &size_bits))
+ break;
+ else
+ {
+ out_insnp->opcode |= size_bits << 4;
+ continue;
+ }
+
+ case 'o':
+ /* A branch expression. */
+ if (! cris_get_expression (&s, &out_insnp->expr))
+ break;
+ else
+ {
+ out_insnp->insn_type = CRIS_INSN_BRANCH;
+ continue;
+ }
+
+ case 'O':
+ /* A BDAP expression for any size, "expr,r". */
+ if (! cris_get_expression (&s, &prefixp->expr))
+ break;
+ else
+ {
+ if (*s != ',')
+ break;
+
+ s++;
+
+ if (!get_gen_reg (&s, &prefixp->base_reg_number))
+ break;
+
+ /* Since 'O' is used with an explicit bdap, we have no
+ "real" instruction. */
+ prefixp->kind = PREFIX_BDAP_IMM;
+ out_insnp->insn_type = CRIS_INSN_NONE;
+ continue;
+ }
+
+ case 'P':
+ /* Special register in bits <15:12>. */
+ if (! get_spec_reg (&s, &out_insnp->spec_reg))
+ break;
+ else
+ {
+ /* Use of some special register names come with a
+ specific warning. Note that we have no ".cpu type"
+ pseudo yet, so some of this is just unused
+ framework. */
+ if (out_insnp->spec_reg->warning)
+ as_warn (out_insnp->spec_reg->warning);
+ else if (out_insnp->spec_reg->applicable_version
+ == cris_ver_warning)
+ /* Others have a generic warning. */
+ as_warn (_("Unimplemented register `%s' specified"),
+ out_insnp->spec_reg->name);
+
+ out_insnp->opcode
+ |= out_insnp->spec_reg->number << 12;
+ continue;
+ }
+
+ case 'p':
+ /* This character is used in the disassembler to
+ recognize a prefix instruction to fold into the
+ addressing mode for the next instruction. It is
+ ignored here. */
+ continue;
+
+ case 'R':
+ /* General register in bits <15:12>. */
+ if (! get_gen_reg (&s, ®no))
+ break;
+ else
+ {
+ out_insnp->opcode |= regno << 12;
+ continue;
+ }
+
+ case 'r':
+ /* General register in bits <3:0>. */
+ if (! get_gen_reg (&s, ®no))
+ break;
+ else
+ {
+ out_insnp->opcode |= regno /* << 0 */;
+ continue;
+ }
+
+ case 'S':
+ /* Source operand in bit <10> and a prefix; a 3-operand
+ prefix. */
+ if (! get_3op_or_dip_prefix_op (&s, prefixp))
+ break;
+ else
+ continue;
+
+ case 's':
+ /* Source operand in bits <10>, <3:0> and optionally a
+ prefix; i.e. an indirect operand or an side-effect
+ prefix. */
+ if (! get_autoinc_prefix_or_indir_op (&s, prefixp, &mode,
+ ®no,
+ &imm_expr_found,
+ &out_insnp->expr))
+ break;
+ else
+ {
+ if (prefixp->kind != PREFIX_NONE)
+ {
+ /* A prefix, so it has the autoincrement bit
+ set. */
+ out_insnp->opcode |= (AUTOINCR_BIT << 8);
+ }
+ else
+ /* No prefix. The "mode" variable contains bits like
+ whether or not this is autoincrement mode. */
+ out_insnp->opcode |= (mode << 10);
+
+ out_insnp->opcode |= regno /* << 0 */ ;
+ continue;
+ }
+
+ case 'x':
+ /* Rs.m in bits <15:12> and <5:4>. */
+ if (! get_gen_reg (&s, ®no)
+ || ! get_bwd_size_modifier (&s, &size_bits))
+ break;
+ else
+ {
+ out_insnp->opcode |=
+ (regno << 12) | (size_bits << 4);
+ continue;
+ }
+
+ case 'y':
+ /* Source operand in bits <10>, <3:0> and optionally a
+ prefix; i.e. an indirect operand or an side-effect
+ prefix.
+
+ The difference to 's' is that this does not allow an
+ "immediate" expression. */
+ if (! get_autoinc_prefix_or_indir_op (&s, prefixp,
+ &mode, ®no,
+ &imm_expr_found,
+ &out_insnp->expr)
+ || imm_expr_found)
+ break;
+ else
+ {
+ if (prefixp->kind != PREFIX_NONE)
+ {
+ /* A prefix, and those matched here always have
+ side-effects (see 's' case). */
+ out_insnp->opcode |= (AUTOINCR_BIT << 8);
+ }
+ else
+ {
+ /* No prefix. The "mode" variable contains bits
+ like whether or not this is autoincrement
+ mode. */
+ out_insnp->opcode |= (mode << 10);
+ }
+
+ out_insnp->opcode |= regno /* << 0 */;
+ continue;
+ }
+
+ case 'z':
+ /* Size modifier (B or W) in bit <4>. */
+ if (! get_bw_size_modifier (&s, &size_bits))
+ break;
+ else
+ {
+ out_insnp->opcode |= size_bits << 4;
+ continue;
+ }
+
+ default:
+ BAD_CASE (*args);
+ }
+
+ /* We get here when we fail a match above or we found a
+ complete match. Break out of this loop. */
+ break;
+ }
+
+ /* Was it a match or a miss? */
+ if (match == 0)
+ {
+ /* If it's just that the args don't match, maybe the next
+ item in the table is the same opcode but with
+ matching operands. */
+ if (instruction[1].name != NULL
+ && ! strcmp (instruction->name, instruction[1].name))
+ {
+ /* Yep. Restart and try that one instead. */
+ ++instruction;
+ s = operands;
+ continue;
+ }
+ else
+ {
+ /* We've come to the end of instructions with this
+ opcode, so it must be an error. */
+ as_bad (_("Illegal operands"));
+ return;
+ }
+ }
+ else
+ {
+ /* We have a match. Check if there's anything more to do. */
+ if (imm_expr_found)
+ {
+ /* There was an immediate mode operand, so we must check
+ that it has an appropriate size. */
+
+ switch (instruction->imm_oprnd_size)
+ {
+ default:
+ case SIZE_NONE:
+ /* Shouldn't happen; this one does not have immediate
+ operands with different sizes. */
+ BAD_CASE (instruction->imm_oprnd_size);
+ break;
+
+ case SIZE_FIX_32:
+ out_insnp->imm_oprnd_size = 4;
+ break;
+
+ case SIZE_SPEC_REG:
+ switch (out_insnp->spec_reg->reg_size)
+ {
+ case 1:
+ if (out_insnp->expr.X_op == O_constant
+ && (out_insnp->expr.X_add_number < -128
+ || out_insnp->expr.X_add_number > 255))
+ as_bad (_("Immediate value not in 8 bit range: %ld"),
+ out_insnp->expr.X_add_number);
+ /* FALLTHROUGH. */
+ case 2:
+ /* FIXME: We need an indicator in the instruction
+ table to pass on, to indicate if we need to check
+ overflow for a signed or unsigned number. */
+ if (out_insnp->expr.X_op == O_constant
+ && (out_insnp->expr.X_add_number < -32768
+ || out_insnp->expr.X_add_number > 65535))
+ as_bad (_("Immediate value not in 16 bit range: %ld"),
+ out_insnp->expr.X_add_number);
+ out_insnp->imm_oprnd_size = 2;
+ break;
+
+ case 4:
+ out_insnp->imm_oprnd_size = 4;
+ break;
+
+ default:
+ BAD_CASE (out_insnp->spec_reg->reg_size);
+ }
+ break;
+
+ case SIZE_FIELD:
+ switch (size_bits)
+ {
+ case 0:
+ if (out_insnp->expr.X_op == O_constant
+ && (out_insnp->expr.X_add_number < -128
+ || out_insnp->expr.X_add_number > 255))
+ as_bad (_("Immediate value not in 8 bit range: %ld"),
+ out_insnp->expr.X_add_number);
+ /* FALLTHROUGH. */
+ case 1:
+ if (out_insnp->expr.X_op == O_constant
+ && (out_insnp->expr.X_add_number < -32768
+ || out_insnp->expr.X_add_number > 65535))
+ as_bad (_("Immediate value not in 16 bit range: %ld"),
+ out_insnp->expr.X_add_number);
+ out_insnp->imm_oprnd_size = 2;
+ break;
+
+ case 2:
+ out_insnp->imm_oprnd_size = 4;
+ break;
+
+ default:
+ BAD_CASE (out_insnp->spec_reg->reg_size);
+ }
+ }
+ }
+ }
+ break;
+ }
+}
+
+
+/* Get a B, W, or D size modifier from the string pointed out by *cPP,
+ which must point to a '.' in front of the modifier. On successful
+ return, *cPP is advanced to the character following the size
+ modifier, and is undefined otherwise.
+
+ cPP Pointer to pointer to string starting
+ with the size modifier.
+
+ size_bitsp Pointer to variable to contain the size bits on
+ successful return.
+
+ Return 1 iff a correct size modifier is found, else 0. */
+
+static int
+get_bwd_size_modifier (cPP, size_bitsp)
+ char **cPP;
+ int *size_bitsp;
+{
+ if (**cPP != '.')
+ return 0;
+ else
+ {
+ /* Consume the '.' */
+ (*cPP)++;
+
+ switch (**cPP)
+ {
+ case 'B':
+ case 'b':
+ *size_bitsp = 0;
+ break;
+
+ case 'W':
+ case 'w':
+ *size_bitsp = 1;
+ break;
+
+ case 'D':
+ case 'd':
+ *size_bitsp = 2;
+ break;
+
+ default:
+ return 0;
+ }
+
+ /* Consume the size letter. */
+ (*cPP)++;
+ return 1;
+ }
+}
+
+
+/* Get a B or W size modifier from the string pointed out by *cPP,
+ which must point to a '.' in front of the modifier. On successful
+ return, *cPP is advanced to the character following the size
+ modifier, and is undefined otherwise.
+
+ cPP Pointer to pointer to string starting
+ with the size modifier.
+
+ size_bitsp Pointer to variable to contain the size bits on
+ successful return.
+
+ Return 1 iff a correct size modifier is found, else 0. */
+
+static int
+get_bw_size_modifier (cPP, size_bitsp)
+ char **cPP;
+ int *size_bitsp;
+{
+ if (**cPP != '.')
+ return 0;
+ else
+ {
+ /* Consume the '.' */
+ (*cPP)++;
+
+ switch (**cPP)
+ {
+ case 'B':
+ case 'b':
+ *size_bitsp = 0;
+ break;
+
+ case 'W':
+ case 'w':
+ *size_bitsp = 1;
+ break;
+
+ default:
+ return 0;
+ }
+
+ /* Consume the size letter. */
+ (*cPP)++;
+ return 1;
+ }
+}
+
+
+/* Get a general register from the string pointed out by *cPP. The
+ variable *cPP is advanced to the character following the general
+ register name on a successful return, and has its initial position
+ otherwise.
+
+ cPP Pointer to pointer to string, beginning with a general
+ register name.
+
+ regnop Pointer to int containing the register number.
+
+ Return 1 iff a correct general register designator is found,
+ else 0. */
+
+static int
+get_gen_reg (cPP, regnop)
+ char **cPP;
+ int *regnop;
+{
+ char *oldp;
+ oldp = *cPP;
+
+ switch (**cPP)
+ {
+ case 'P':
+ case 'p':
+ /* "P" as in "PC"? Consume the "P". */
+ (*cPP)++;
+
+ if ((**cPP == 'C' || **cPP == 'c')
+ && ! isalnum ((*cPP)[1]))
+ {
+ /* It's "PC": consume the "c" and we're done. */
+ (*cPP)++;
+ *regnop = REG_PC;
+ return 1;
+ }
+ break;
+
+ case 'R':
+ case 'r':
+ /* Hopefully r[0-9] or r1[0-5]. Consume 'R' or 'r' */
+ (*cPP)++;
+
+ if (isdigit (**cPP))
+ {
+ /* It's r[0-9]. Consume and check the next digit. */
+ *regnop = **cPP - '0';
+ (*cPP)++;
+
+ if (! isalnum (**cPP))
+ {
+ /* No more digits, we're done. */
+ return 1;
+ }
+ else
+ {
+ /* One more digit. Consume and add. */
+ *regnop = *regnop*10 + (**cPP - '0');
+
+ /* We need to check for a valid register number; Rn,
+ 0 <= n <= MAX_REG. */
+ if (*regnop <= MAX_REG)
+ {
+ /* Consume second digit. */
+ (*cPP)++;
+ return 1;
+ }
+ }
+ }
+ break;
+
+ case 'S':
+ case 's':
+ /* "S" as in "SP"? Consume the "S". */
+ (*cPP)++;
+ if (**cPP == 'P' || **cPP == 'p')
+ {
+ /* It's "SP": consume the "p" and we're done. */
+ (*cPP)++;
+ *regnop = REG_SP;
+ return 1;
+ }
+ break;
+
+ default:
+ /* Just here to silence compilation warnings. */
+ ;
+ }
+
+ /* We get here if we fail. Restore the pointer. */
+ *cPP = oldp;
+ return 0;
+}
+
+
+/* Get a special register from the string pointed out by *cPP. The
+ variable *cPP is advanced to the character following the special
+ register name if one is found, and retains its original position
+ otherwise.
+
+ cPP Pointer to pointer to string starting with a special register
+ name.
+
+ sregpp Pointer to Pointer to struct spec_reg, where a pointer to the
+ register description will be stored.
+
+ Return 1 iff a correct special register name is found. */
+
+static int
+get_spec_reg (cPP, sregpp)
+ char **cPP;
+ const struct cris_spec_reg **sregpp;
+{
+ char *s1;
+ const char *s2;
+
+ const struct cris_spec_reg *sregp;
+
+ /* Loop over all special registers. */
+ for (sregp = cris_spec_regs;
+ sregp->name != NULL;
+ sregp++)
+ {
+
+ /* Start over from beginning of the supposed name. */
+ s1 = *cPP;
+ s2 = sregp->name;
+
+ while (*s2 != '\0'
+ && (isupper (*s1) ? tolower (*s1) == *s2 : *s1 == *s2))
+ {
+ s1++;
+ s2++;
+ }
+
+ /* For a match, we must have consumed the name in the table, and we
+ must be outside what could be part of a name. Assume here that a
+ test for alphanumerics is sufficient for a name test. */
+ if (*s2 == 0 && ! isalnum (*s1))
+ {
+ /* We have a match. Update the pointer and be done. */
+ *cPP = s1;
+ *sregpp = sregp;
+ return 1;
+ }
+ }
+
+ /* If we got here, we did not find any name. */
+ return 0;
+}
+
+
+/* Get an unprefixed or side-effect-prefix operand from the string pointed
+ out by *cPP. The pointer *cPP is advanced to the character following
+ the indirect operand if we have success, else it contains an undefined
+ value.
+
+ cPP Pointer to pointer to string beginning with the first
+ character of the supposed operand.
+
+ prefixp Pointer to structure containing an optional instruction
+ prefix.
+
+ is_autoincp Pointer to int indicating the indirect or autoincrement
+ bits.
+
+ src_regnop Pointer to int containing the source register number in
+ the instruction.
+
+ imm_foundp Pointer to an int indicating if an immediate expression
+ is found.
+
+ imm_exprP Pointer to a structure containing an immediate
+ expression, if success and if *imm_foundp is nonzero.
+
+ Return 1 iff a correct indirect operand is found. */
+
+static int
+get_autoinc_prefix_or_indir_op (cPP, prefixp, is_autoincp, src_regnop,
+ imm_foundp, imm_exprP)
+ char **cPP;
+ struct cris_prefix *prefixp;
+ int *is_autoincp;
+ int *src_regnop;
+ int *imm_foundp;
+ expressionS *imm_exprP;
+{
+ /* Assume there was no immediate mode expression. */
+ *imm_foundp = 0;
+
+ if (**cPP == '[')
+ {
+ /* So this operand is one of:
+ Indirect: [rN]
+ Autoincrement: [rN+]
+ Indexed with assign: [rN=rM+rO.S]
+ Offset with assign: [rN=rM+I], [rN=rM+[rO].s], [rN=rM+[rO+].s]
+
+ Either way, consume the '['. */
+ (*cPP)++;
+
+ /* Get the rN register. */
+ if (! get_gen_reg (cPP, src_regnop))
+ /* If there was no register, then this cannot match. */
+ return 0;
+ else
+ {
+ /* We got the register, now check the next character. */
+ switch (**cPP)
+ {
+ case ']':
+ /* Indirect mode. We're done here. */
+ prefixp->kind = PREFIX_NONE;
+ *is_autoincp = 0;
+ break;
+
+ case '+':
+ /* This must be an auto-increment mode, if there's a
+ match. */
+ prefixp->kind = PREFIX_NONE;
+ *is_autoincp = 1;
+
+ /* We consume this character and break out to check the
+ closing ']'. */
+ (*cPP)++;
+ break;
+
+ case '=':
+ /* This must be indexed with assign, or offset with assign
+ to match. */
+ (*cPP)++;
+
+ /* Either way, the next thing must be a register. */
+ if (! get_gen_reg (cPP, &prefixp->base_reg_number))
+ /* No register, no match. */
+ return 0;
+ else
+ {
+ /* We've consumed "[rN=rM", so we must be looking at
+ "+rO.s]" or "+I]", or "-I]", or "+[rO].s]" or
+ "+[rO+].s]". */
+ if (**cPP == '+')
+ {
+ int index_reg_number;
+ (*cPP)++;
+
+ if (**cPP == '[')
+ {
+ int size_bits;
+ /* This must be [rx=ry+[rz].s] or
+ [rx=ry+[rz+].s] or no match. We must be
+ looking at rz after consuming the '['. */
+ (*cPP)++;
+
+ if (!get_gen_reg (cPP, &index_reg_number))
+ return 0;
+
+ prefixp->kind = PREFIX_BDAP;
+ prefixp->opcode
+ = (BDAP_INDIR_OPCODE
+ + (prefixp->base_reg_number << 12)
+ + index_reg_number);
+
+ if (**cPP == '+')
+ {
+ /* We've seen "[rx=ry+[rz+" here, so now we
+ know that there must be "].s]" left to
+ check. */
+ (*cPP)++;
+ prefixp->opcode |= AUTOINCR_BIT << 8;
+ }
+
+ /* If it wasn't autoincrement, we don't need to
+ add anything. */
+
+ /* Check the next-to-last ']'. */
+ if (**cPP != ']')
+ return 0;
+
+ (*cPP)++;
+
+ /* Check the ".s" modifier. */
+ if (! get_bwd_size_modifier (cPP, &size_bits))
+ return 0;
+
+ prefixp->opcode |= size_bits << 4;
+
+ /* Now we got [rx=ry+[rz+].s or [rx=ry+[rz].s.
+ We break out to check the final ']'. */
+ break;
+ }
+ else
+ /* It wasn't an idirection. Check if it's a
+ register. */
+ if (get_gen_reg (cPP, &index_reg_number))
+ {
+ int size_bits;
+
+ /* Indexed with assign mode: "[rN+rM.S]". */
+ prefixp->kind = PREFIX_BIAP;
+ prefixp->opcode
+ = (BIAP_OPCODE + (index_reg_number << 12)
+ + prefixp->base_reg_number /* << 0 */);
+
+ if (! get_bwd_size_modifier (cPP, &size_bits))
+ /* Size missing, this isn't a match. */
+ return 0;
+ else
+ {
+ /* Size found, break out to check the
+ final ']'. */
+ prefixp->opcode |= size_bits << 4;
+ break;
+ }
+ }
+ else
+ /* Not a register. Then this must be "[rN+I]". */
+ if (cris_get_expression (cPP, &prefixp->expr))
+ {
+ /* We've got offset with assign mode. Fill
+ in the blanks and break out to match the
+ final ']'. */
+ prefixp->kind = PREFIX_BDAP_IMM;
+ break;
+ }
+ else
+ /* Neither register nor expression found, so
+ this can't be a match. */
+ return 0;
+ }
+ else
+ /* Not "[rN+" but perhaps "[rN-"? */
+ if (**cPP == '-')
+ {
+ /* We must have an offset with assign mode. */
+ if (! cris_get_expression (cPP, &prefixp->expr))
+ /* No expression, no match. */
+ return 0;
+ else
+ {
+ /* We've got offset with assign mode. Fill
+ in the blanks and break out to match the
+ final ']'. */
+ prefixp->kind = PREFIX_BDAP_IMM;
+ break;
+ }
+ }
+ else
+ /* Neither '+' nor '-' after "[rN=rM". Lose. */
+ return 0;
+ }
+ default:
+ /* Neither ']' nor '+' nor '=' after "[rN". Lose. */
+ return 0;
+ }
+ }
+
+ /* When we get here, we have a match and will just check the closing
+ ']'. We can still fail though. */
+ if (**cPP != ']')
+ return 0;
+ else
+ {
+ /* Don't forget to consume the final ']'.
+ Then return in glory. */
+ (*cPP)++;
+ return 1;
+ }
+ }
+ else
+ /* No indirection. Perhaps a constant? */
+ if (cris_get_expression (cPP, imm_exprP))
+ {
+ /* Expression found, this is immediate mode. */
+ prefixp->kind = PREFIX_NONE;
+ *is_autoincp = 1;
+ *src_regnop = REG_PC;
+ *imm_foundp = 1;
+ return 1;
+ }
+
+ /* No luck today. */
+ return 0;
+}
+
+
+/* This function gets an indirect operand in a three-address operand
+ combination from the string pointed out by *cPP. The pointer *cPP is
+ advanced to the character following the indirect operand on success, or
+ has an unspecified value on failure.
+
+ cPP Pointer to pointer to string begining
+ with the operand
+
+ prefixp Pointer to structure containing an
+ instruction prefix
+
+ Returns 1 iff a correct indirect operand is found. */
+
+static int
+get_3op_or_dip_prefix_op (cPP, prefixp)
+ char **cPP;
+ struct cris_prefix *prefixp;
+{
+ if (**cPP != '[')
+ /* We must have a '[' or it's a clean failure. */
+ return 0;
+ else
+ {
+ int reg_number;
+
+ /* Eat the first '['. */
+ (*cPP)++;
+
+ if (**cPP == '[')
+ {
+ /* A second '[', so this must be double-indirect mode. */
+ (*cPP)++;
+ prefixp->kind = PREFIX_DIP;
+ prefixp->opcode = DIP_OPCODE;
+
+ /* Get the register or fail entirely. */
+ if (! get_gen_reg (cPP, ®_number))
+ return 0;
+ else
+ {
+ prefixp->opcode |= reg_number /* << 0 */ ;
+ if (**cPP == '+')
+ {
+ /* Since we found a '+', this must be double-indirect
+ autoincrement mode. */
+ (*cPP)++;
+ prefixp->opcode |= AUTOINCR_BIT << 8;
+ }
+
+ /* There's nothing particular to do, if this was a
+ double-indirect *without* autoincrement. */
+ }
+
+ /* Check the first ']'. The second one is checked at the end. */
+ if (**cPP != ']')
+ return 0;
+
+ /* Eat the first ']', so we'll be looking at a second ']'. */
+ (*cPP)++;
+ }
+ else
+ /* No second '['. Then we should have a register here, making
+ it "[rN". */
+ if (get_gen_reg (cPP, &prefixp->base_reg_number))
+ {
+ /* This must be indexed or offset mode: "[rN+I]" or
+ "[rN+rM.S]" or "[rN+[rM].S]" or "[rN+[rM+].S]". */
+ if (**cPP == '+')
+ {
+ /* Not the first alternative, must be one of the last
+ three. */
+ int index_reg_number;
+
+ (*cPP)++;
+
+ if (**cPP == '[')
+ {
+ /* This is "[rx+["... Expect a register next. */
+ int size_bits;
+ (*cPP)++;
+
+ if (!get_gen_reg (cPP, &index_reg_number))
+ return 0;
+
+ prefixp->kind = PREFIX_BDAP;
+ prefixp->opcode
+ = (BDAP_INDIR_OPCODE
+ + (prefixp->base_reg_number << 12)
+ + index_reg_number);
+
+ /* We've seen "[rx+[ry", so check if this is
+ autoincrement. */
+ if (**cPP == '+')
+ {
+ /* Yep, now at "[rx+[ry+". */
+ (*cPP)++;
+ prefixp->opcode |= AUTOINCR_BIT << 8;
+ }
+ /* If it wasn't autoincrement, we don't need to
+ add anything. */
+
+ /* Check a first closing ']': "[rx+[ry]" or
+ "[rx+[ry+]". */
+ if (**cPP != ']')
+ return 0;
+ (*cPP)++;
+
+ /* Now expect a size modifier ".S". */
+ if (! get_bwd_size_modifier (cPP, &size_bits))
+ return 0;
+
+ prefixp->opcode |= size_bits << 4;
+
+ /* Ok, all interesting stuff has been seen:
+ "[rx+[ry+].S" or "[rx+[ry].S". We only need to
+ expect a final ']', which we'll do in a common
+ closing session. */
+ }
+ else
+ /* Seen "[rN+", but not a '[', so check if we have a
+ register. */
+ if (get_gen_reg (cPP, &index_reg_number))
+ {
+ /* This is indexed mode: "[rN+rM.S]" or
+ "[rN+rM.S+]". */
+ int size_bits;
+ prefixp->kind = PREFIX_BIAP;
+ prefixp->opcode
+ = (BIAP_OPCODE
+ | prefixp->base_reg_number /* << 0 */
+ | (index_reg_number << 12));
+
+ /* */
+ if (! get_bwd_size_modifier (cPP, &size_bits))
+ /* Missing size, so fail. */
+ return 0;
+ else
+ /* Size found. Add that piece and drop down to
+ the common checking of the closing ']'. */
+ prefixp->opcode |= size_bits << 4;
+ }
+ else
+ /* Seen "[rN+", but not a '[' or a register, so then
+ it must be a constant "I". */
+ if (cris_get_expression (cPP, &prefixp->expr))
+ {
+ /* Expression found, so fill in the bits of offset
+ mode and drop down to check the closing ']'. */
+ prefixp->kind = PREFIX_BDAP_IMM;
+ }
+ else
+ /* Nothing valid here: lose. */
+ return 0;
+ }
+ else
+ /* Seen "[rN" but no '+', so check if it's a '-'. */
+ if (**cPP == '-')
+ {
+ /* Yep, we must have offset mode. */
+ if (! cris_get_expression (cPP, &prefixp->expr))
+ /* No expression, so we lose. */
+ return 0;
+ else
+ {
+ /* Expression found to make this offset mode, so
+ fill those bits and drop down to check the
+ closing ']'. */
+ prefixp->kind = PREFIX_BDAP_IMM;
+ }
+ }
+ else
+ {
+ /* We've seen "[rN", but not '+' or '-'; rather a ']'.
+ Hmm. Normally this is a simple indirect mode that we
+ shouldn't match, but if we expect ']', then we have a
+ zero offset, so it can be a three-address-operand,
+ like "[rN],rO,rP", thus offset mode.
+
+ Don't eat the ']', that will be done in the closing
+ ceremony. */
+ prefixp->expr.X_op = O_constant;
+ prefixp->expr.X_add_number = 0;
+ prefixp->expr.X_add_symbol = NULL;
+ prefixp->expr.X_op_symbol = NULL;
+ prefixp->kind = PREFIX_BDAP_IMM;
+ }
+ }
+ else
+ {
+ /* A '[', but no second '[', and no register. Check if we
+ have an expression, making this "[I]" for a double-indirect
+ prefix. */
+ if (cris_get_expression (cPP, &prefixp->expr))
+ {
+ /* Expression found, the so called absolute mode for a
+ double-indirect prefix on PC. */
+ prefixp->kind = PREFIX_DIP;
+ prefixp->opcode
+ = DIP_OPCODE | (AUTOINCR_BIT << 8) | REG_PC;
+ prefixp->reloc = BFD_RELOC_32;
+ }
+ else
+ /* Neither '[' nor register nor expression. We lose. */
+ return 0;
+ }
+ }
+
+ /* We get here as a closing ceremony to a successful match. We just
+ need to check the closing ']'. */
+ if (**cPP != ']')
+ /* Oops. Close but no air-polluter. */
+ return 0;
+
+ /* Don't forget to consume that ']', before returning in glory. */
+ (*cPP)++;
+ return 1;
+}
+
+
+/* Get an expression from the string pointed out by *cPP.
+ The pointer *cPP is advanced to the character following the expression
+ on a success, or retains its original value otherwise.
+
+ cPP Pointer to pointer to string beginning with the expression.
+
+ exprP Pointer to structure containing the expression.
+
+ Return 1 iff a correct expression is found. */
+
+static int
+cris_get_expression (cPP, exprP)
+ char **cPP;
+ expressionS *exprP;
+{
+ char *saved_input_line_pointer;
+ segT exp;
+
+ /* The "expression" function expects to find an expression at the
+ global variable input_line_pointer, so we have to save it to give
+ the impression that we don't fiddle with global variables. */
+ saved_input_line_pointer = input_line_pointer;
+ input_line_pointer = *cPP;
+
+ exp = expression (exprP);
+ if (exprP->X_op == O_illegal || exprP->X_op == O_absent)
+ {
+ input_line_pointer = saved_input_line_pointer;
+ return 0;
+ }
+
+ /* Everything seems to be fine, just restore the global
+ input_line_pointer and say we're successful. */
+ *cPP = input_line_pointer;
+ input_line_pointer = saved_input_line_pointer;
+ return 1;
+}
+
+
+/* Get a sequence of flag characters from *spp. The pointer *cPP is
+ advanced to the character following the expression. The flag
+ characters are consecutive, no commas or spaces.
+
+ cPP Pointer to pointer to string beginning with the expression.
+
+ flagp Pointer to int to return the flags expression.
+
+ Return 1 iff a correct flags expression is found. */
+
+static int
+get_flags (cPP, flagsp)
+ char **cPP;
+ int *flagsp;
+{
+ for (;;)
+ {
+ switch (**cPP)
+ {
+ case 'd':
+ case 'D':
+ case 'm':
+ case 'M':
+ *flagsp |= 0x80;
+ break;
+
+ case 'e':
+ case 'E':
+ case 'b':
+ case 'B':
+ *flagsp |= 0x40;
+ break;
+
+ case 'i':
+ case 'I':
+ *flagsp |= 0x20;
+ break;
+
+ case 'x':
+ case 'X':
+ *flagsp |= 0x10;
+ break;
+
+ case 'n':
+ case 'N':
+ *flagsp |= 0x8;
+ break;
+
+ case 'z':
+ case 'Z':
+ *flagsp |= 0x4;
+ break;
+
+ case 'v':
+ case 'V':
+ *flagsp |= 0x2;
+ break;
+
+ case 'c':
+ case 'C':
+ *flagsp |= 1;
+ break;
+
+ default:
+ /* We consider this successful if we stop at a comma or
+ whitespace. Anything else, and we consider it a failure. */
+ if (**cPP != ','
+ && **cPP != 0
+ && ! isspace (**cPP))
+ return 0;
+ else
+ return 1;
+ }
+
+ /* Don't forget to consume each flag character. */
+ (*cPP)++;
+ }
+}
+
+
+/* Generate code and fixes for a BDAP prefix.
+
+ base_regno Int containing the base register number.
+
+ exprP Pointer to structure containing the offset expression. */
+
+static void
+gen_bdap (base_regno, exprP)
+ int base_regno;
+ expressionS *exprP;
+{
+ unsigned int opcode;
+ char *opcodep;
+
+ /* Put out the prefix opcode; assume quick immediate mode at first. */
+ opcode = BDAP_QUICK_OPCODE | (base_regno << 12);
+ opcodep = frag_more (2);
+ md_number_to_chars (opcodep, opcode, 2);
+
+ if (exprP->X_op == O_constant)
+ {
+ /* We have an absolute expression that we know the size of right
+ now. */
+ long int value;
+ int size;
+
+ value = exprP->X_add_number;
+ if (value < -32768 || value > 32767)
+ /* Outside range for a "word", make it a dword. */
+ size = 2;
+ else
+ /* Assume "word" size. */
+ size = 1;
+
+ /* If this is a signed-byte value, we can fit it into the prefix
+ insn itself. */
+ if (value >= -128 && value <= 127)
+ opcodep[0] = value;
+ else
+ {
+ /* This is a word or dword displacement, which will be put in a
+ word or dword after the prefix. */
+ char *p;
+
+ opcodep[0] = BDAP_PC_LOW + (size << 4);
+ opcodep[1] &= 0xF0;
+ opcodep[1] |= BDAP_INCR_HIGH;
+ p = frag_more (1 << size);
+ md_number_to_chars (p, value, 1 << size);
+ }
+ }
+ else
+ /* The expression is not defined yet but may become absolute. We make
+ it a relocation to be relaxed. */
+ frag_var (rs_machine_dependent, 4, 0,
+ ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX, STATE_UNDF),
+ exprP->X_add_symbol, exprP->X_add_number, opcodep);
+}
+
+
+/* Encode a branch displacement in the range -256..254 into the form used
+ by CRIS conditional branch instructions.
+
+ offset The displacement value in bytes. */
+
+static int
+branch_disp (offset)
+ int offset;
+{
+ int disp;
+
+ disp = offset & 0xFE;
+
+ if (offset < 0)
+ disp |= 1;
+
+ return disp;
+}
+
+
+/* Generate code and fixes for a 32-bit conditional branch instruction
+ created by "extending" an existing 8-bit branch instruction.
+
+ opcodep Pointer to the word containing the original 8-bit branch
+ instruction.
+
+ writep Pointer to "extension area" following the first instruction
+ word.
+
+ fragP Pointer to the frag containing the instruction.
+
+ add_symP, Parts of the destination address expression.
+ sub_symP,
+ add_num. */
+
+static void
+gen_cond_branch_32 (opcodep, writep, fragP, add_symP, sub_symP, add_num)
+ char *opcodep;
+ char *writep;
+ fragS *fragP;
+ symbolS *add_symP;
+ symbolS *sub_symP;
+ long int add_num;
+{
+ if (warn_for_branch_expansion)
+ {
+ /* FIXME: Find out and change to as_warn_where. Add testcase. */
+ as_warn (_("32-bit conditional branch generated"));
+ }
+
+ /* Here, writep points to what will be opcodep + 2. First, we change
+ the actual branch in opcodep[0] and opcodep[1], so that in the
+ final insn, it will look like:
+ opcodep+10: Bcc .-6
+
+ This means we don't have to worry about changing the opcode or
+ messing with te delay-slot instruction. So, we move it to last in
+ the "extended" branch, and just change the displacement. Admittedly,
+ it's not the optimal extended construct, but we should get this
+ rarely enough that it shouldn't matter. */
+
+ writep[8] = branch_disp (-2-6);
+ writep[9] = opcodep[1];
+
+ /* Then, we change the branch to an unconditional branch over the
+ extended part, to the new location of the Bcc:
+ opcodep: BA .+10
+ opcodep+2: NOP
+
+ Note that these two writes are to currently different locations,
+ merged later. */
+
+ md_number_to_chars (opcodep, BA_QUICK_OPCODE + 8, 2);
+ md_number_to_chars (writep, NOP_OPCODE, 2);
+
+ /* Then the extended thing, the 32-bit jump insn.
+ opcodep+4: JUMP [PC+] */
+
+ md_number_to_chars (writep + 2, JUMP_PC_INCR_OPCODE, 2);
+
+ /* We have to fill in the actual value too.
+ opcodep+6: .DWORD
+ This is most probably an expression, but we can cope with an absolute
+ value too. FIXME: Testcase needed. */
+
+ if (add_symP == NULL && sub_symP == NULL)
+ /* An absolute address. */
+ md_number_to_chars (writep + 4, add_num, 4);
+ else
+ {
+ /* Not absolute, we have to make it a frag for later evaluation. */
+ know (sub_symP == 0);
+
+ fix_new (fragP, writep + 4 - fragP->fr_literal, 4, add_symP,
+ add_num, 0, BFD_RELOC_32);
+ }
+}
+
+
+/* This *could* be:
+
+ Turn a string in input_line_pointer into a floating point constant of
+ type type, and store the appropriate bytes in *litp. The number of
+ LITTLENUMS emitted is stored in *sizep.
+
+ type A character from FLTCHARS that describes what kind of
+ floating-point number is wanted.
+
+ litp A pointer to an array that the result should be stored in.
+
+ sizep A pointer to an integer where the size of the result is stored.
+
+ But we don't support floating point constants in assembly code *at all*,
+ since it's suboptimal and just opens up bug opportunities. GCC emits
+ the bit patterns as hex. All we could do here is to emit what GCC
+ would have done in the first place. *Nobody* writes floating-point
+ code as assembly code, but if they do, they should be able enough to
+ find out the correct bit patterns and use them. */
+
+char *
+md_atof (type, litp, sizep)
+ char type ATTRIBUTE_UNUSED;
+ char *litp ATTRIBUTE_UNUSED;
+ int *sizep ATTRIBUTE_UNUSED;
+{
+ /* FIXME: Is this function mentioned in the internals.texi manual? If
+ not, add it. */
+ return _("Bad call to md_atof () - floating point formats are not supported");
+}
+
+
+/* Turn a number as a fixS * into a series of bytes that represents the
+ number on the target machine. The purpose of this procedure is the
+ same as that of md_number_to_chars but this procedure is supposed to
+ handle general bit field fixes and machine-dependent fixups.
+
+ bufp Pointer to an array where the result should be stored.
+
+ val The value to store.
+
+ n The number of bytes in "val" that should be stored.
+
+ fixP The fix to be applied to the bit field starting at bufp. */
+
+static void
+cris_number_to_imm (bufp, val, n, fixP)
+ char *bufp;
+ long val;
+ int n;
+ fixS *fixP;
+{
+ segT sym_seg;
+
+ know (n <= 4);
+ know (fixP);
+
+ /* We put the relative "vma" for the other segment for inter-segment
+ relocations in the object data to stay binary "compatible" (with an
+ uninteresting old version) for the relocation.
+ Maybe delete some day. */
+ if (fixP->fx_addsy
+ && (sym_seg = S_GET_SEGMENT (fixP->fx_addsy)) != now_seg)
+ val += sym_seg->vma;
+
+ switch (fixP->fx_r_type)
+ {
+ /* Ditto here, we put the addend into the object code as
+ well as the reloc addend. Keep it that way for now, to simplify
+ regression tests on the object file contents. FIXME: Seems
+ uninteresting now that we have a test suite. */
+
+ case BFD_RELOC_32:
+ /* No use having warnings here, since most hosts have a 32-bit type
+ for "long" (which will probably change soon, now that I wrote
+ this). */
+ bufp[3] = (val >> 24) & 0xFF;
+ bufp[2] = (val >> 16) & 0xFF;
+ bufp[1] = (val >> 8) & 0xFF;
+ bufp[0] = val & 0xFF;
+ break;
+
+ /* FIXME: The 16 and 8-bit cases should have a way to check
+ whether a signed or unsigned (or any signedness) number is
+ accepted.
+ FIXME: Does the as_bad calls find the line number by themselves,
+ or should we change them into as_bad_where? */
+
+ case BFD_RELOC_16:
+ if (val > 0xffff || val < -32768)
+ as_bad (_("Value not in 16 bit range: %ld"), val);
+ if (! fixP->fx_addsy)
+ {
+ bufp[1] = (val >> 8) & 0xFF;
+ bufp[0] = val & 0xFF;
+ }
+ break;
+
+ case BFD_RELOC_8:
+ if (val > 255 || val < -128)
+ as_bad (_("Value not in 8 bit range: %ld"), val);
+ if (! fixP->fx_addsy)
+ bufp[0] = val & 0xFF;
+ break;
+
+ case BFD_RELOC_CRIS_UNSIGNED_4:
+ if (val > 15 || val < 0)
+ as_bad (_("Value not in 4 bit unsigned range: %ld"), val);
+ if (! fixP->fx_addsy)
+ bufp[0] |= val & 0x0F;
+ break;
+
+ case BFD_RELOC_CRIS_UNSIGNED_5:
+ if (val > 31 || val < 0)
+ as_bad (_("Value not in 5 bit unsigned range: %ld"), val);
+ if (! fixP->fx_addsy)
+ bufp[0] |= val & 0x1F;
+ break;
+
+ case BFD_RELOC_CRIS_SIGNED_6:
+ if (val > 31 || val < -32)
+ as_bad (_("Value not in 6 bit range: %ld"), val);
+ if (! fixP->fx_addsy)
+ bufp[0] |= val & 0x3F;
+ break;
+
+ case BFD_RELOC_CRIS_UNSIGNED_6:
+ if (val > 63 || val < 0)
+ as_bad (_("Value not in 6 bit unsigned range: %ld"), val);
+ if (! fixP->fx_addsy)
+ bufp[0] |= val & 0x3F;
+ break;
+
+ case BFD_RELOC_CRIS_BDISP8:
+ if (! fixP->fx_addsy)
+ bufp[0] = branch_disp (val);
+ break;
+
+ case BFD_RELOC_NONE:
+ /* May actually happen automatically. For example at broken
+ words, if the word turns out not to be broken.
+ FIXME: When? Which testcase? */
+ if (! fixP->fx_addsy)
+ md_number_to_chars (bufp, val, n);
+ break;
+
+ case BFD_RELOC_VTABLE_INHERIT:
+ /* This borrowed from tc-ppc.c on a whim. */
+ if (fixP->fx_addsy
+ && !S_IS_DEFINED (fixP->fx_addsy)
+ && !S_IS_WEAK (fixP->fx_addsy))
+ S_SET_WEAK (fixP->fx_addsy);
+ /* FALLTHROUGH. */
+ case BFD_RELOC_VTABLE_ENTRY:
+ /* FIXME: I'm not sure why we do this (as does other ports), but it
+ might be that this relocation can only be finished at link time. */
+ fixP->fx_done = 0;
+ break;
+
+ default:
+ BAD_CASE (fixP->fx_r_type);
+ }
+}
+
+
+/* Processes machine-dependent command line options. Called once for
+ each option on the command line that the machine-independent part of
+ GAS does not understand. */
+int
+md_parse_option (arg, argp)
+ int arg;
+ char *argp ATTRIBUTE_UNUSED;
+{
+ switch (arg)
+ {
+ case 'H':
+ case 'h':
+ md_show_usage (stdout);
+ exit (0); /* Don't continue */
+
+ case 'N':
+ warn_for_branch_expansion = 1;
+ return 1;
+
+ default:
+ return 0;
+ }
+}
+
+/* Round up a section size to the appropriate boundary. */
+valueT
+md_section_align (segment, size)
+ segT segment;
+ valueT size;
+{
+ /* Round all sects to multiple of 4, except the bss section, which
+ we'll round to word-size.
+
+ FIXME: Check if this really matters. All sections should be
+ rounded up, and all sections should (optionally) be assumed to be
+ dword-aligned, it's just that there is actual usage of linking to a
+ multiple of two. */
+ if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
+ {
+ if (segment == bss_section)
+ return (size + 1) & ~1;
+ return (size + 3) & ~3;
+ }
+ else
+ {
+ /* FIXME: Is this wanted? It matches the testsuite, but that's not
+ really a valid reason. */
+ if (segment == text_section)
+ return (size + 3) & ~3;
+ }
+
+ return size;
+}
+
+
+/* Generate a machine-dependent relocation. */
+arelent *
+tc_gen_reloc (section, fixP)
+ asection *section ATTRIBUTE_UNUSED;
+ fixS *fixP;
+{
+ arelent *relP;
+ bfd_reloc_code_real_type code;
+
+ switch (fixP->fx_r_type)
+ {
+ case BFD_RELOC_32:
+ case BFD_RELOC_16:
+ case BFD_RELOC_8:
+ case BFD_RELOC_VTABLE_INHERIT:
+ case BFD_RELOC_VTABLE_ENTRY:
+ code = fixP->fx_r_type;
+ break;
+ default:
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("Semantics error. This type of operand can not be relocated, it must be an assembly-time constant"));
+ return 0;
+ }
+
+ relP = (arelent *) xmalloc (sizeof (arelent));
+ assert (relP != 0);
+ relP->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
+ *relP->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
+ relP->address = fixP->fx_frag->fr_address + fixP->fx_where;
+
+ if (fixP->fx_pcrel)
+ /* FIXME: Is this correct? */
+ relP->addend = fixP->fx_addnumber;
+ else
+ /* At least *this one* is correct. */
+ relP->addend = fixP->fx_offset;
+
+ /* This is the standard place for KLUDGEs to work around bugs in
+ bfd_install_relocation (first such note in the documentation
+ appears with binutils-2.8).
+
+ That function bfd_install_relocation does the wrong thing with
+ putting stuff into the addend of a reloc (it should stay out) for a
+ weak symbol. The really bad thing is that it adds the
+ "segment-relative offset" of the symbol into the reloc. In this
+ case, the reloc should instead be relative to the symbol with no
+ other offset than the assembly code shows; and since the symbol is
+ weak, any local definition should be ignored until link time (or
+ thereafter).
+ To wit: weaksym+42 should be weaksym+42 in the reloc,
+ not weaksym+(offset_from_segment_of_local_weaksym_definition)
+
+ To "work around" this, we subtract the segment-relative offset of
+ "known" weak symbols. This evens out the extra offset.
+
+ That happens for a.out but not for ELF, since for ELF,
+ bfd_install_relocation uses the "special function" field of the
+ howto, and does not execute the code that needs to be undone. */
+
+ if (OUTPUT_FLAVOR == bfd_target_aout_flavour
+ && fixP->fx_addsy && S_IS_WEAK (fixP->fx_addsy)
+ && ! bfd_is_und_section (S_GET_SEGMENT (fixP->fx_addsy)))
+ {
+ relP->addend -= S_GET_VALUE (fixP->fx_addsy);
+ }
+
+ relP->howto = bfd_reloc_type_lookup (stdoutput, code);
+ if (! relP->howto)
+ {
+ const char *name;
+
+ name = S_GET_NAME (fixP->fx_addsy);
+ if (name == NULL)
+ name = _("<unknown>");
+ as_fatal (_("Cannot generate relocation type for symbol %s, code %s"),
+ name, bfd_get_reloc_code_name (code));
+ }
+
+ return relP;
+}
+
+
+/* Machine-dependent usage-output. */
+void
+md_show_usage (stream)
+ FILE *stream;
+{
+ fprintf (stream, _("\n-- GNU as for CRIS\n"));
+ fprintf (stream, "\n");
+ fprintf (stream,
+ _("*** Usage: as-cris [switches] [-o objectfile] [files...]\n"));
+ fprintf (stream, _("Target-specific switches:\n"));
+ fprintf (stream, _(" -h, -H : Don't execute, print this help text.\n"));
+ fprintf (stream,
+ _(" -N : Warn when branches are expanded to jumps.\n\n"));
+ fprintf (stream, _("Use as-cris --help to see more options.\n"));
+ fprintf (stream, _("objectfile : Output file in the a.out format %s"),
+ _("described in the users manual.\n"));
+ fprintf (stream, _(" Default output file is \"a.out\".\n"));
+ fprintf (stream, _("files ... : Input files in the source format %s"),
+ _(" described in the users manual.\n"));
+ fprintf (stream, _(" Default input file is standard input.\n"));
+ fprintf (stream, _("Description : Assembler for the CRIS processor.\n"));
+}
+
+
+/* Apply a fixS (fixup of an instruction or data that we didn't have
+ enough info to complete immediately) to the data in a frag. */
+
+int
+md_apply_fix (fixP, valP)
+ fixS *fixP;
+ valueT *valP;
+{
+ long val = *valP;
+
+ char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+
+ if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
+ fixP->fx_done = 1;
+
+ if (fixP->fx_bit_fixP || fixP->fx_im_disp != 0)
+ {
+ as_bad_where (fixP->fx_file, fixP->fx_line, _("Invalid relocation"));
+ fixP->fx_done = 1;
+ }
+ else
+ {
+ /* I took this from tc-arc.c, since we used to not support
+ fx_subsy != NULL. I'm not totally sure it's TRT. */
+ if (fixP->fx_subsy != (symbolS *) NULL)
+ {
+ if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section)
+ val -= S_GET_VALUE (fixP->fx_subsy);
+ else
+ {
+ /* We can't actually support subtracting a symbol. */
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("expression too complex"));
+ }
+ }
+
+ cris_number_to_imm (buf, val, fixP->fx_size, fixP);
+ }
+
+ return 1;
+}
+
+
+/* All relocations are relative to the location just after the fixup;
+ the address of the fixup plus its size. */
+
+long
+md_pcrel_from (fixP)
+ fixS *fixP;
+{
+ valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
+
+ /* FIXME: We get here only at the end of assembly, when X in ".-X" is
+ still unknown. Since we don't have pc-relative relocations, this
+ is invalid. What to do if anything for a.out, is to add
+ pc-relative relocations everywhere including the elinux program
+ loader. */
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("Invalid pc-relative relocation"));
+ return fixP->fx_size + addr;
+}
+
+
+/* We have no need to give defaults for symbol-values. */
+symbolS *
+md_undefined_symbol (name)
+ char *name ATTRIBUTE_UNUSED;
+{
+ return 0;
+}
+
+
+/* Definition of TC_FORCE_RELOCATION.
+ FIXME: Unsure of this. Can we omit it? Just copied from tc-i386.c
+ when doing multi-object format with ELF, since it's the only other
+ multi-object-format target with a.out and ELF. */
+int
+md_cris_force_relocation (fixp)
+ struct fix *fixp;
+{
+ if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
+ || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
+ return 1;
+ return 0;
+}
+
+/* Check and emit error if broken-word handling has failed to fix up a
+ case-table. This is called from write.c, after doing everything it
+ knows about how to handle broken words. */
+
+void
+tc_cris_check_adjusted_broken_word (new_offset, brokwP)
+ offsetT new_offset;
+ struct broken_word *brokwP;
+{
+ if (new_offset > 32767 || new_offset < -32768)
+ /* We really want a genuine error, not a warning, so make it one. */
+ as_bad_where (brokwP->frag->fr_file, brokwP->frag->fr_line,
+ _("Adjusted signed .word (%ld) overflows: `switch'-statement too large."),
+ (long) new_offset);
+}
+
+
+/*
+ * Local variables:
+ * eval: (c-set-style "gnu")
+ * indent-tabs-mode: t
+ * End:
+ */
--- /dev/null
+/* tc-cris.h -- Header file for tc-cris.c, the CRIS GAS port.
+ Copyright (C) 2000 Free Software Foundation, Inc.
+
+ Contributed by Axis Communications AB, Lund, Sweden.
+ Originally written for GAS 1.38.1 by Mikael Asker.
+ Updated, BFDized and GNUified by Hans-Peter Nilsson.
+
+ 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. */
+
+/* See the GAS "internal" document for general documentation on this.
+ It is called internals.texi (internals.info when makeinfo:d), but is
+ not installed or makeinfo:d by "make info". */
+
+/* Functions and variables that aren't declared in tc.h are declared here,
+ with the type/prototype that is used in the local extern-declaration of
+ their usage. */
+
+#ifndef TC_CRIS
+#define TC_CRIS
+
+/* Multi-target support is always on. */
+extern const char *cris_target_format PARAMS ((void));
+#define TARGET_FORMAT cris_target_format ()
+
+#define TARGET_ARCH bfd_arch_cris
+
+#define TARGET_BYTES_BIG_ENDIAN 0
+
+extern const char *md_shortopts;
+extern struct option md_longopts[];
+extern size_t md_longopts_size;
+
+extern const pseudo_typeS md_pseudo_table[];
+
+#define tc_comment_chars cris_comment_chars
+extern const char cris_comment_chars[];
+extern const char line_comment_chars[];
+extern const char line_separator_chars[];
+extern const char EXP_CHARS[];
+extern const char FLT_CHARS[];
+
+/* This should be optional, since it is ignored as an escape (assumed to
+ be itself) if it is not recognized. */
+#define ONLY_STANDARD_ESCAPES
+
+/* Note that we do not define TC_EQUAL_IN_INSN, since its current use is
+ in the instruction rather than the operand, and thus does not come to
+ use for side-effect assignments such as "and.d [r0 = r1 + 42], r3". */
+#define md_operand(x)
+
+#define md_number_to_chars number_to_chars_littleendian
+
+extern const int md_short_jump_size;
+extern const int md_long_jump_size;
+
+/* There's no use having different functions for this; the sizes are the
+ same. Note that we can't #define md_short_jump_size here. */
+#define md_create_short_jump md_create_long_jump
+
+extern const struct relax_type md_cris_relax_table[];
+#define TC_GENERIC_RELAX_TABLE md_cris_relax_table
+
+#define TC_HANDLES_FX_DONE
+
+#define TC_FORCE_RELOCATION(fixp) md_cris_force_relocation (fixp)
+extern int md_cris_force_relocation PARAMS ((struct fix *));
+
+/* This is really a workaround for a bug in write.c that resolves relocs
+ for weak symbols - it should be postponed to the link stage or later.
+ */
+#define tc_fix_adjustable(X) \
+ ((! (X)->fx_addsy || ! S_IS_WEAK((X)->fx_addsy)) \
+ && (X)->fx_r_type != BFD_RELOC_VTABLE_INHERIT \
+ && (X)->fx_r_type != BFD_RELOC_VTABLE_ENTRY)
+
+/* When we have fixups against constant expressions, we get a GAS-specific
+ section symbol at no extra charge for obscure reasons in
+ adjust_reloc_syms. Since ELF outputs section symbols, it gladly
+ outputs this "*ABS*" symbol in every object. Avoid that. */
+#define tc_frob_symbol(symp, punt) \
+ do { \
+ if (OUTPUT_FLAVOR == bfd_target_elf_flavour \
+ && (symp) == section_symbol (absolute_section)) \
+ (punt) = 1; \
+ } while (0)
+
+#define LISTING_HEADER "GAS for CRIS"
+
+#if 0
+/* The testsuite does not let me define these, although they IMHO should
+ be preferred over the default. */
+#define LISTING_WORD_SIZE 2
+#define LISTING_LHS_WIDTH 4
+#define LISTING_LHS_WIDTH_SECOND 4
+#endif
+
+/* END of declaration and definitions described in the "internals"
+ document. */
+
+/* Do this, or we will never know what hit us when the
+ broken-word-fixes break. Do _not_ use WARN_SIGNED_OVERFLOW_WORD,
+ it is only for use with WORKING_DOT_WORD and warns about most stuff.
+ (still in 2.9.1). */
+struct broken_word;
+extern void tc_cris_check_adjusted_broken_word PARAMS ((offsetT,
+ struct
+ broken_word *));
+#define TC_CHECK_ADJUSTED_BROKEN_DOT_WORD(new_offset, brokw) \
+ tc_cris_check_adjusted_broken_word ((offsetT) (new_offset), brokw)
+
+/* We don't want any implicit alignment, so we do nothing. */
+#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)
+
+#endif /* TC_CRIS */
+/*
+ * Local variables:
+ * eval: (c-set-style "gnu")
+ * indent-tabs-mode: t
+ * End:
+ */
fi
+case "$target" in
+NONE) lt_target="$host" ;;
+*) lt_target="$target" ;;
+esac
+
# Check for any special flags to pass to ltconfig.
libtool_flags="--cache-file=$cache_file"
test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
# Some flags need to be propagated to the compiler or linker for good
# libtool support.
-case "$host" in
+case "$lt_target" in
*-*-irix6*)
# Find out which ABI we are using.
- echo '#line 1396 "configure"' > conftest.$ac_ext
- if { (eval echo configure:1397: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+ echo '#line 1401 "configure"' > conftest.$ac_ext
+ if { (eval echo configure:1402: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
case "`/usr/bin/file conftest.o`" in
*32-bit*)
LD="${LD-ld} -32"
SAVE_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -belf"
echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
-echo "configure:1418: checking whether the C compiler needs -belf" >&5
+echo "configure:1423: checking whether the C compiler needs -belf" >&5
if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 1423 "configure"
+#line 1428 "configure"
#include "confdefs.h"
int main() {
; return 0; }
EOF
-if { (eval echo configure:1430: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1435: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
lt_cv_cc_needs_belf=yes
else
LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \
DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \
${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
-$libtool_flags --no-verify $ac_aux_dir/ltmain.sh $host \
+$libtool_flags --no-verify $ac_aux_dir/ltmain.sh $lt_target \
|| { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
# Reload cache, that may have been modified by ltconfig
avr-*-*) fmt=elf bfd_gas=yes ;;
+ cris-*-*) fmt=multi bfd_gas=yes ;;
+
d10v-*-*) fmt=elf bfd_gas=yes ;;
d30v-*-*) fmt=elf bfd_gas=yes ;;
i386-*-aout) emulation="i386aout" ;;
i386-*-coff) emulation="i386coff" ;;
i386-*-elf) emulation="i386elf" ;;
+
+ # Always all formats. Having a.out first makes it the default.
+ cris-*-*) emulation="crisaout criself" ;;
esac
emulations="$emulations $emulation"
# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2439: checking for $ac_word" >&5
+echo "configure:2449: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2469: checking for $ac_word" >&5
+echo "configure:2479: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "cl", so it can be a program name with args.
set dummy cl; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2520: checking for $ac_word" >&5
+echo "configure:2530: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
fi
echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:2552: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+echo "configure:2562: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
cat > conftest.$ac_ext << EOF
-#line 2563 "configure"
+#line 2573 "configure"
#include "confdefs.h"
main(){return(0);}
EOF
-if { (eval echo configure:2568: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2578: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
ac_cv_prog_cc_works=yes
# If we can't run a trivial program, we are probably using a cross compiler.
if (./conftest; exit) 2>/dev/null; then
{ echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
fi
echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:2594: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:2604: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
cross_compiling=$ac_cv_prog_cc_cross
echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:2599: checking whether we are using GNU C" >&5
+echo "configure:2609: checking whether we are using GNU C" >&5
if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
yes;
#endif
EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:2608: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:2618: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
ac_cv_prog_gcc=yes
else
ac_cv_prog_gcc=no
ac_save_CFLAGS="$CFLAGS"
CFLAGS=
echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:2627: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:2637: checking whether ${CC-cc} accepts -g" >&5
if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2664: checking for $ac_word" >&5
+echo "configure:2674: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YACC'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
test -n "$YACC" || YACC="yacc"
echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
-echo "configure:2695: checking how to run the C preprocessor" >&5
+echo "configure:2705: checking how to run the C preprocessor" >&5
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
CPP=
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp.
cat > conftest.$ac_ext <<EOF
-#line 2710 "configure"
+#line 2720 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax Error
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2716: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2726: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
:
rm -rf conftest*
CPP="${CC-cc} -E -traditional-cpp"
cat > conftest.$ac_ext <<EOF
-#line 2727 "configure"
+#line 2737 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax Error
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2733: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2743: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
:
rm -rf conftest*
CPP="${CC-cc} -nologo -E"
cat > conftest.$ac_ext <<EOF
-#line 2744 "configure"
+#line 2754 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax Error
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2750: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2760: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
:
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2780: checking for $ac_word" >&5
+echo "configure:2790: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_LEX'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "flex", so it can be a program name with args.
set dummy flex; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2813: checking for $ac_word" >&5
+echo "configure:2823: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_LEX'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
*) ac_lib=l ;;
esac
echo $ac_n "checking for yywrap in -l$ac_lib""... $ac_c" 1>&6
-echo "configure:2847: checking for yywrap in -l$ac_lib" >&5
+echo "configure:2857: checking for yywrap in -l$ac_lib" >&5
ac_lib_var=`echo $ac_lib'_'yywrap | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-l$ac_lib $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 2855 "configure"
+#line 2865 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
/* We use char because int might match the return type of a gcc2
yywrap()
; return 0; }
EOF
-if { (eval echo configure:2866: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2876: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
fi
echo $ac_n "checking lex output file root""... $ac_c" 1>&6
-echo "configure:2889: checking lex output file root" >&5
+echo "configure:2899: checking lex output file root" >&5
if eval "test \"`echo '$''{'ac_cv_prog_lex_root'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
echo $ac_n "checking whether yytext is a pointer""... $ac_c" 1>&6
-echo "configure:2910: checking whether yytext is a pointer" >&5
+echo "configure:2920: checking whether yytext is a pointer" >&5
if eval "test \"`echo '$''{'ac_cv_prog_lex_yytext_pointer'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_save_LIBS="$LIBS"
LIBS="$LIBS $LEXLIB"
cat > conftest.$ac_ext <<EOF
-#line 2922 "configure"
+#line 2932 "configure"
#include "confdefs.h"
`cat $LEX_OUTPUT_ROOT.c`
int main() {
; return 0; }
EOF
-if { (eval echo configure:2929: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2939: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
ac_cv_prog_lex_yytext_pointer=yes
else
ALL_LINGUAS=
echo $ac_n "checking for POSIXized ISC""... $ac_c" 1>&6
-echo "configure:2953: checking for POSIXized ISC" >&5
+echo "configure:2963: checking for POSIXized ISC" >&5
if test -d /etc/conf/kconfig.d &&
grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1
then
fi
echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6
-echo "configure:2974: checking for ANSI C header files" >&5
+echo "configure:2984: checking for ANSI C header files" >&5
if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 2979 "configure"
+#line 2989 "configure"
#include "confdefs.h"
#include <stdlib.h>
#include <stdarg.h>
#include <float.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2987: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2997: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
if test $ac_cv_header_stdc = yes; then
# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
cat > conftest.$ac_ext <<EOF
-#line 3004 "configure"
+#line 3014 "configure"
#include "confdefs.h"
#include <string.h>
EOF
if test $ac_cv_header_stdc = yes; then
# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
cat > conftest.$ac_ext <<EOF
-#line 3022 "configure"
+#line 3032 "configure"
#include "confdefs.h"
#include <stdlib.h>
EOF
:
else
cat > conftest.$ac_ext <<EOF
-#line 3043 "configure"
+#line 3053 "configure"
#include "confdefs.h"
#include <ctype.h>
#define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
exit (0); }
EOF
-if { (eval echo configure:3054: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:3064: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
then
:
else
fi
echo $ac_n "checking for working const""... $ac_c" 1>&6
-echo "configure:3078: checking for working const" >&5
+echo "configure:3088: checking for working const" >&5
if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3083 "configure"
+#line 3093 "configure"
#include "confdefs.h"
int main() {
; return 0; }
EOF
-if { (eval echo configure:3132: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3142: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
ac_cv_c_const=yes
else
fi
echo $ac_n "checking for inline""... $ac_c" 1>&6
-echo "configure:3153: checking for inline" >&5
+echo "configure:3163: checking for inline" >&5
if eval "test \"`echo '$''{'ac_cv_c_inline'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_cv_c_inline=no
for ac_kw in inline __inline__ __inline; do
cat > conftest.$ac_ext <<EOF
-#line 3160 "configure"
+#line 3170 "configure"
#include "confdefs.h"
int main() {
} $ac_kw foo() {
; return 0; }
EOF
-if { (eval echo configure:3167: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3177: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
ac_cv_c_inline=$ac_kw; break
else
esac
echo $ac_n "checking for off_t""... $ac_c" 1>&6
-echo "configure:3193: checking for off_t" >&5
+echo "configure:3203: checking for off_t" >&5
if eval "test \"`echo '$''{'ac_cv_type_off_t'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3198 "configure"
+#line 3208 "configure"
#include "confdefs.h"
#include <sys/types.h>
#if STDC_HEADERS
fi
echo $ac_n "checking for size_t""... $ac_c" 1>&6
-echo "configure:3226: checking for size_t" >&5
+echo "configure:3236: checking for size_t" >&5
if eval "test \"`echo '$''{'ac_cv_type_size_t'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3231 "configure"
+#line 3241 "configure"
#include "confdefs.h"
#include <sys/types.h>
#if STDC_HEADERS
# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
# for constant arguments. Useless!
echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6
-echo "configure:3261: checking for working alloca.h" >&5
+echo "configure:3271: checking for working alloca.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_alloca_h'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3266 "configure"
+#line 3276 "configure"
#include "confdefs.h"
#include <alloca.h>
int main() {
char *p = alloca(2 * sizeof(int));
; return 0; }
EOF
-if { (eval echo configure:3273: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3283: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
ac_cv_header_alloca_h=yes
else
fi
echo $ac_n "checking for alloca""... $ac_c" 1>&6
-echo "configure:3294: checking for alloca" >&5
+echo "configure:3304: checking for alloca" >&5
if eval "test \"`echo '$''{'ac_cv_func_alloca_works'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3299 "configure"
+#line 3309 "configure"
#include "confdefs.h"
#ifdef __GNUC__
char *p = (char *) alloca(1);
; return 0; }
EOF
-if { (eval echo configure:3327: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3337: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
ac_cv_func_alloca_works=yes
else
echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6
-echo "configure:3359: checking whether alloca needs Cray hooks" >&5
+echo "configure:3369: checking whether alloca needs Cray hooks" >&5
if eval "test \"`echo '$''{'ac_cv_os_cray'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3364 "configure"
+#line 3374 "configure"
#include "confdefs.h"
#if defined(CRAY) && ! defined(CRAY2)
webecray
if test $ac_cv_os_cray = yes; then
for ac_func in _getb67 GETB67 getb67; do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3389: checking for $ac_func" >&5
+echo "configure:3399: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3394 "configure"
+#line 3404 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:3417: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3427: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
fi
echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6
-echo "configure:3444: checking stack direction for C alloca" >&5
+echo "configure:3454: checking stack direction for C alloca" >&5
if eval "test \"`echo '$''{'ac_cv_c_stack_direction'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_cv_c_stack_direction=0
else
cat > conftest.$ac_ext <<EOF
-#line 3452 "configure"
+#line 3462 "configure"
#include "confdefs.h"
find_stack_direction ()
{
exit (find_stack_direction() < 0);
}
EOF
-if { (eval echo configure:3471: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:3481: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
then
ac_cv_c_stack_direction=1
else
do
ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:3496: checking for $ac_hdr" >&5
+echo "configure:3506: checking for $ac_hdr" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3501 "configure"
+#line 3511 "configure"
#include "confdefs.h"
#include <$ac_hdr>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3506: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3516: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
for ac_func in getpagesize
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3535: checking for $ac_func" >&5
+echo "configure:3545: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3540 "configure"
+#line 3550 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:3563: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3573: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
done
echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:3588: checking for working mmap" >&5
+echo "configure:3598: checking for working mmap" >&5
if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_cv_func_mmap_fixed_mapped=no
else
cat > conftest.$ac_ext <<EOF
-#line 3596 "configure"
+#line 3606 "configure"
#include "confdefs.h"
/* Thanks to Mike Haertel and Jim Avera for this test.
}
EOF
-if { (eval echo configure:3736: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:3746: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
then
ac_cv_func_mmap_fixed_mapped=yes
else
do
ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:3764: checking for $ac_hdr" >&5
+echo "configure:3774: checking for $ac_hdr" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3769 "configure"
+#line 3779 "configure"
#include "confdefs.h"
#include <$ac_hdr>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3774: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3784: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
__argz_count __argz_stringify __argz_next
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3804: checking for $ac_func" >&5
+echo "configure:3814: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3809 "configure"
+#line 3819 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:3832: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3842: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
for ac_func in stpcpy
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3861: checking for $ac_func" >&5
+echo "configure:3871: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3866 "configure"
+#line 3876 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:3889: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3899: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
if test $ac_cv_header_locale_h = yes; then
echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
-echo "configure:3923: checking for LC_MESSAGES" >&5
+echo "configure:3933: checking for LC_MESSAGES" >&5
if eval "test \"`echo '$''{'am_cv_val_LC_MESSAGES'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 3928 "configure"
+#line 3938 "configure"
#include "confdefs.h"
#include <locale.h>
int main() {
return LC_MESSAGES
; return 0; }
EOF
-if { (eval echo configure:3935: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3945: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
am_cv_val_LC_MESSAGES=yes
else
fi
fi
echo $ac_n "checking whether NLS is requested""... $ac_c" 1>&6
-echo "configure:3956: checking whether NLS is requested" >&5
+echo "configure:3966: checking whether NLS is requested" >&5
# Check whether --enable-nls or --disable-nls was given.
if test "${enable_nls+set}" = set; then
enableval="$enable_nls"
EOF
echo $ac_n "checking whether included gettext is requested""... $ac_c" 1>&6
-echo "configure:3976: checking whether included gettext is requested" >&5
+echo "configure:3986: checking whether included gettext is requested" >&5
# Check whether --with-included-gettext or --without-included-gettext was given.
if test "${with_included_gettext+set}" = set; then
withval="$with_included_gettext"
ac_safe=`echo "libintl.h" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for libintl.h""... $ac_c" 1>&6
-echo "configure:3995: checking for libintl.h" >&5
+echo "configure:4005: checking for libintl.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4000 "configure"
+#line 4010 "configure"
#include "confdefs.h"
#include <libintl.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:4005: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:4015: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
echo "$ac_t""yes" 1>&6
echo $ac_n "checking for gettext in libc""... $ac_c" 1>&6
-echo "configure:4022: checking for gettext in libc" >&5
+echo "configure:4032: checking for gettext in libc" >&5
if eval "test \"`echo '$''{'gt_cv_func_gettext_libc'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4027 "configure"
+#line 4037 "configure"
#include "confdefs.h"
#include <libintl.h>
int main() {
return (int) gettext ("")
; return 0; }
EOF
-if { (eval echo configure:4034: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4044: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gt_cv_func_gettext_libc=yes
else
if test "$gt_cv_func_gettext_libc" != "yes"; then
echo $ac_n "checking for bindtextdomain in -lintl""... $ac_c" 1>&6
-echo "configure:4050: checking for bindtextdomain in -lintl" >&5
+echo "configure:4060: checking for bindtextdomain in -lintl" >&5
ac_lib_var=`echo intl'_'bindtextdomain | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-lintl $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 4058 "configure"
+#line 4068 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
/* We use char because int might match the return type of a gcc2
bindtextdomain()
; return 0; }
EOF
-if { (eval echo configure:4069: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4079: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
echo "$ac_t""yes" 1>&6
echo $ac_n "checking for gettext in libintl""... $ac_c" 1>&6
-echo "configure:4085: checking for gettext in libintl" >&5
+echo "configure:4095: checking for gettext in libintl" >&5
if eval "test \"`echo '$''{'gt_cv_func_gettext_libintl'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4090 "configure"
+#line 4100 "configure"
#include "confdefs.h"
int main() {
return (int) gettext ("")
; return 0; }
EOF
-if { (eval echo configure:4097: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4107: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gt_cv_func_gettext_libintl=yes
else
# Extract the first word of "msgfmt", so it can be a program name with args.
set dummy msgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:4125: checking for $ac_word" >&5
+echo "configure:4135: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
for ac_func in dcgettext
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:4159: checking for $ac_func" >&5
+echo "configure:4169: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4164 "configure"
+#line 4174 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:4187: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4197: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
# Extract the first word of "gmsgfmt", so it can be a program name with args.
set dummy gmsgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:4214: checking for $ac_word" >&5
+echo "configure:4224: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "xgettext", so it can be a program name with args.
set dummy xgettext; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:4250: checking for $ac_word" >&5
+echo "configure:4260: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
fi
cat > conftest.$ac_ext <<EOF
-#line 4282 "configure"
+#line 4292 "configure"
#include "confdefs.h"
int main() {
return _nl_msg_cat_cntr
; return 0; }
EOF
-if { (eval echo configure:4290: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4300: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
CATOBJEXT=.gmo
DATADIRNAME=share
# Extract the first word of "msgfmt", so it can be a program name with args.
set dummy msgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:4322: checking for $ac_word" >&5
+echo "configure:4332: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "gmsgfmt", so it can be a program name with args.
set dummy gmsgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:4356: checking for $ac_word" >&5
+echo "configure:4366: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "xgettext", so it can be a program name with args.
set dummy xgettext; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:4392: checking for $ac_word" >&5
+echo "configure:4402: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
LINGUAS=
else
echo $ac_n "checking for catalogs to be installed""... $ac_c" 1>&6
-echo "configure:4482: checking for catalogs to be installed" >&5
+echo "configure:4492: checking for catalogs to be installed" >&5
NEW_LINGUAS=
for lang in ${LINGUAS=$ALL_LINGUAS}; do
case "$ALL_LINGUAS" in
if test "$CATOBJEXT" = ".cat"; then
ac_safe=`echo "linux/version.h" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for linux/version.h""... $ac_c" 1>&6
-echo "configure:4510: checking for linux/version.h" >&5
+echo "configure:4520: checking for linux/version.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4515 "configure"
+#line 4525 "configure"
#include "confdefs.h"
#include <linux/version.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:4520: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:4530: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
-echo "configure:4583: checking whether to enable maintainer-specific portions of Makefiles" >&5
+echo "configure:4593: checking whether to enable maintainer-specific portions of Makefiles" >&5
# Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
if test "${enable_maintainer_mode+set}" = set; then
enableval="$enable_maintainer_mode"
echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
-echo "configure:4606: checking for Cygwin environment" >&5
+echo "configure:4616: checking for Cygwin environment" >&5
if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4611 "configure"
+#line 4621 "configure"
#include "confdefs.h"
int main() {
return __CYGWIN__;
; return 0; }
EOF
-if { (eval echo configure:4622: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4632: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
ac_cv_cygwin=yes
else
CYGWIN=
test "$ac_cv_cygwin" = yes && CYGWIN=yes
echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
-echo "configure:4639: checking for mingw32 environment" >&5
+echo "configure:4649: checking for mingw32 environment" >&5
if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4644 "configure"
+#line 4654 "configure"
#include "confdefs.h"
int main() {
return __MINGW32__;
; return 0; }
EOF
-if { (eval echo configure:4651: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4661: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
ac_cv_mingw32=yes
else
echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
-echo "configure:4670: checking for executable suffix" >&5
+echo "configure:4680: checking for executable suffix" >&5
if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
rm -f conftest*
echo 'int main () { return 0; }' > conftest.$ac_ext
ac_cv_exeext=
- if { (eval echo configure:4680: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
+ if { (eval echo configure:4690: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
for file in conftest.*; do
case $file in
*.c | *.o | *.obj | *.ilk | *.pdb) ;;
do
ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:4705: checking for $ac_hdr" >&5
+echo "configure:4715: checking for $ac_hdr" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4710 "configure"
+#line 4720 "configure"
#include "confdefs.h"
#include <$ac_hdr>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:4715: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:4725: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
# Put this here so that autoconf's "cross-compiling" message doesn't confuse
# people who are not cross-compiling but are compiling cross-assemblers.
echo $ac_n "checking whether compiling a cross-assembler""... $ac_c" 1>&6
-echo "configure:4745: checking whether compiling a cross-assembler" >&5
+echo "configure:4755: checking whether compiling a cross-assembler" >&5
if test "${host}" = "${target}"; then
cross_gas=no
else
# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
# for constant arguments. Useless!
echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6
-echo "configure:4760: checking for working alloca.h" >&5
+echo "configure:4770: checking for working alloca.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_alloca_h'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4765 "configure"
+#line 4775 "configure"
#include "confdefs.h"
#include <alloca.h>
int main() {
char *p = alloca(2 * sizeof(int));
; return 0; }
EOF
-if { (eval echo configure:4772: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4782: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
ac_cv_header_alloca_h=yes
else
fi
echo $ac_n "checking for alloca""... $ac_c" 1>&6
-echo "configure:4793: checking for alloca" >&5
+echo "configure:4803: checking for alloca" >&5
if eval "test \"`echo '$''{'ac_cv_func_alloca_works'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4798 "configure"
+#line 4808 "configure"
#include "confdefs.h"
#ifdef __GNUC__
char *p = (char *) alloca(1);
; return 0; }
EOF
-if { (eval echo configure:4826: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4836: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
ac_cv_func_alloca_works=yes
else
echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6
-echo "configure:4858: checking whether alloca needs Cray hooks" >&5
+echo "configure:4868: checking whether alloca needs Cray hooks" >&5
if eval "test \"`echo '$''{'ac_cv_os_cray'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4863 "configure"
+#line 4873 "configure"
#include "confdefs.h"
#if defined(CRAY) && ! defined(CRAY2)
webecray
if test $ac_cv_os_cray = yes; then
for ac_func in _getb67 GETB67 getb67; do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:4888: checking for $ac_func" >&5
+echo "configure:4898: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 4893 "configure"
+#line 4903 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:4916: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4926: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
fi
echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6
-echo "configure:4943: checking stack direction for C alloca" >&5
+echo "configure:4953: checking stack direction for C alloca" >&5
if eval "test \"`echo '$''{'ac_cv_c_stack_direction'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_cv_c_stack_direction=0
else
cat > conftest.$ac_ext <<EOF
-#line 4951 "configure"
+#line 4961 "configure"
#include "confdefs.h"
find_stack_direction ()
{
exit (find_stack_direction() < 0);
}
EOF
-if { (eval echo configure:4970: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:4980: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
then
ac_cv_c_stack_direction=1
else
fi
echo $ac_n "checking for inline""... $ac_c" 1>&6
-echo "configure:4992: checking for inline" >&5
+echo "configure:5002: checking for inline" >&5
if eval "test \"`echo '$''{'ac_cv_c_inline'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_cv_c_inline=no
for ac_kw in inline __inline__ __inline; do
cat > conftest.$ac_ext <<EOF
-#line 4999 "configure"
+#line 5009 "configure"
#include "confdefs.h"
int main() {
} $ac_kw foo() {
; return 0; }
EOF
-if { (eval echo configure:5006: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5016: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
ac_cv_c_inline=$ac_kw; break
else
for ac_func in unlink remove
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:5036: checking for $ac_func" >&5
+echo "configure:5046: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 5041 "configure"
+#line 5051 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:5064: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5074: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
for ac_func in sbrk
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:5093: checking for $ac_func" >&5
+echo "configure:5103: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 5098 "configure"
+#line 5108 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:5121: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5131: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
case "${need_libm}" in
yes)
LIBM=
-case "$host" in
+case "$lt_target" in
*-*-beos* | *-*-cygwin*)
# These system don't have libm
;;
*-ncr-sysv4.3*)
echo $ac_n "checking for _mwvalidcheckl in -lmw""... $ac_c" 1>&6
-echo "configure:5156: checking for _mwvalidcheckl in -lmw" >&5
+echo "configure:5166: checking for _mwvalidcheckl in -lmw" >&5
ac_lib_var=`echo mw'_'_mwvalidcheckl | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-lmw $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 5164 "configure"
+#line 5174 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
/* We use char because int might match the return type of a gcc2
_mwvalidcheckl()
; return 0; }
EOF
-if { (eval echo configure:5175: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5185: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
fi
echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
-echo "configure:5196: checking for main in -lm" >&5
+echo "configure:5206: checking for main in -lm" >&5
ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-lm $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 5204 "configure"
+#line 5214 "configure"
#include "confdefs.h"
int main() {
main()
; return 0; }
EOF
-if { (eval echo configure:5211: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5221: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
;;
*)
echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
-echo "configure:5234: checking for main in -lm" >&5
+echo "configure:5244: checking for main in -lm" >&5
ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-lm $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 5242 "configure"
+#line 5252 "configure"
#include "confdefs.h"
int main() {
main()
; return 0; }
EOF
-if { (eval echo configure:5249: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5259: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
# enough, but on some of those systems, the assert macro relies on requoting
# working properly!
echo $ac_n "checking for working assert macro""... $ac_c" 1>&6
-echo "configure:5280: checking for working assert macro" >&5
+echo "configure:5290: checking for working assert macro" >&5
if eval "test \"`echo '$''{'gas_cv_assert_ok'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 5285 "configure"
+#line 5295 "configure"
#include "confdefs.h"
#include <assert.h>
#include <stdio.h>
; return 0; }
EOF
-if { (eval echo configure:5301: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5311: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gas_cv_assert_ok=yes
else
"
echo $ac_n "checking whether declaration is required for strstr""... $ac_c" 1>&6
-echo "configure:5342: checking whether declaration is required for strstr" >&5
+echo "configure:5352: checking whether declaration is required for strstr" >&5
if eval "test \"`echo '$''{'gas_cv_decl_needed_strstr'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 5347 "configure"
+#line 5357 "configure"
#include "confdefs.h"
$gas_test_headers
int main() {
; return 0; }
EOF
-if { (eval echo configure:5358: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5368: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gas_cv_decl_needed_strstr=no
else
echo $ac_n "checking whether declaration is required for malloc""... $ac_c" 1>&6
-echo "configure:5379: checking whether declaration is required for malloc" >&5
+echo "configure:5389: checking whether declaration is required for malloc" >&5
if eval "test \"`echo '$''{'gas_cv_decl_needed_malloc'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 5384 "configure"
+#line 5394 "configure"
#include "confdefs.h"
$gas_test_headers
int main() {
; return 0; }
EOF
-if { (eval echo configure:5395: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5405: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gas_cv_decl_needed_malloc=no
else
echo $ac_n "checking whether declaration is required for free""... $ac_c" 1>&6
-echo "configure:5416: checking whether declaration is required for free" >&5
+echo "configure:5426: checking whether declaration is required for free" >&5
if eval "test \"`echo '$''{'gas_cv_decl_needed_free'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 5421 "configure"
+#line 5431 "configure"
#include "confdefs.h"
$gas_test_headers
int main() {
; return 0; }
EOF
-if { (eval echo configure:5432: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5442: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gas_cv_decl_needed_free=no
else
echo $ac_n "checking whether declaration is required for sbrk""... $ac_c" 1>&6
-echo "configure:5453: checking whether declaration is required for sbrk" >&5
+echo "configure:5463: checking whether declaration is required for sbrk" >&5
if eval "test \"`echo '$''{'gas_cv_decl_needed_sbrk'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 5458 "configure"
+#line 5468 "configure"
#include "confdefs.h"
$gas_test_headers
int main() {
; return 0; }
EOF
-if { (eval echo configure:5469: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5479: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gas_cv_decl_needed_sbrk=no
else
echo $ac_n "checking whether declaration is required for environ""... $ac_c" 1>&6
-echo "configure:5490: checking whether declaration is required for environ" >&5
+echo "configure:5500: checking whether declaration is required for environ" >&5
if eval "test \"`echo '$''{'gas_cv_decl_needed_environ'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 5495 "configure"
+#line 5505 "configure"
#include "confdefs.h"
$gas_test_headers
int main() {
; return 0; }
EOF
-if { (eval echo configure:5506: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5516: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gas_cv_decl_needed_environ=no
else
# for it?
echo $ac_n "checking whether declaration is required for errno""... $ac_c" 1>&6
-echo "configure:5530: checking whether declaration is required for errno" >&5
+echo "configure:5540: checking whether declaration is required for errno" >&5
if eval "test \"`echo '$''{'gas_cv_decl_needed_errno'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 5535 "configure"
+#line 5545 "configure"
#include "confdefs.h"
#ifdef HAVE_ERRNO_H
; return 0; }
EOF
-if { (eval echo configure:5550: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5560: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gas_cv_decl_needed_errno=no
else
avr-*-*) fmt=elf bfd_gas=yes ;;
+ cris-*-*) fmt=multi bfd_gas=yes ;;
+
d10v-*-*) fmt=elf bfd_gas=yes ;;
d30v-*-*) fmt=elf bfd_gas=yes ;;
i386-*-aout) emulation="i386aout" ;;
i386-*-coff) emulation="i386coff" ;;
i386-*-elf) emulation="i386elf" ;;
+
+ # Always all formats. Having a.out first makes it the default.
+ cris-*-*) emulation="crisaout criself" ;;
esac
emulations="$emulations $emulation"
cgen.h
cond.c
cond.c
+config/e-crisaout.c
+config/e-criself.c
config/e-i386aout.c
config/e-i386coff.c
config/e-i386elf.c
config/tc-arm.h
config/tc-avr.c
config/tc-avr.h
+config/tc-cris.c
+config/tc-cris.h
config/tc-d10v.c
config/tc-d10v.h
config/tc-d30v.c
ecoff.h
ehopt.c
ehopt.c
-emul.h
emul-target.h
+emul.h
expr.c
expr.c
expr.h
flonum-copy.c
flonum-copy.c
-flonum.h
flonum-konst.c
flonum-konst.c
flonum-mult.c
flonum-mult.c
+flonum.h
frags.c
frags.c
frags.h
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
-"POT-Creation-Date: 2000-07-17 14:23-0700\n"
+"POT-Creation-Date: 2000-07-20 19:36+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
msgid "EOF in Comment: Newline inserted"
msgstr ""
-#: as.c:148
+#: as.c:149
msgid "missing emulation mode name"
msgstr ""
-#: as.c:163
+#: as.c:164
#, c-format
msgid "unrecognized emulation name `%s'"
msgstr ""
-#: as.c:210
+#: as.c:211
#, c-format
msgid "GNU assembler version %s (%s) using BFD version %s"
msgstr ""
-#: as.c:213
+#: as.c:214
#, c-format
msgid "GNU assembler version %s (%s)"
msgstr ""
-#: as.c:222
+#: as.c:223
#, c-format
msgid "Usage: %s [option...] [asmfile...]\n"
msgstr ""
-#: as.c:224
+#: as.c:225
msgid ""
"Options:\n"
" -a[sub-option...]\t turn on listings\n"
" \t =FILE list to FILE (must be last sub-option)\n"
msgstr ""
-#: as.c:238
+#: as.c:239
msgid " -D produce assembler debugging messages\n"
msgstr ""
-#: as.c:240
+#: as.c:241
msgid " --defsym SYM=VAL define symbol SYM to given value\n"
msgstr ""
-#: as.c:256
+#: as.c:257
#, c-format
msgid " emulate output (default %s)\n"
msgstr ""
-#: as.c:260
+#: as.c:261
msgid " -f skip whitespace and comment preprocessing\n"
msgstr ""
-#: as.c:262
+#: as.c:263
msgid " --gstabs generate stabs debugging information\n"
msgstr ""
-#: as.c:264
+#: as.c:265
msgid " --gdwarf2 generate DWARF2 debugging information\n"
msgstr ""
-#: as.c:266
+#: as.c:267
msgid " --help show this message and exit\n"
msgstr ""
-#: as.c:268
+#: as.c:269
msgid ""
" -I DIR add DIR to search list for .include directives\n"
msgstr ""
-#: as.c:270
+#: as.c:271
msgid " -J don't warn about signed overflow\n"
msgstr ""
-#: as.c:272
+#: as.c:273
msgid ""
" -K warn when differences altered for long "
"displacements\n"
msgstr ""
-#: as.c:274
+#: as.c:275
msgid " -L,--keep-locals keep local symbols (e.g. starting with `L')\n"
msgstr ""
-#: as.c:276
+#: as.c:277
msgid " -M,--mri assemble in MRI compatibility mode\n"
msgstr ""
-#: as.c:278
+#: as.c:279
msgid ""
" --MD FILE write dependency information in FILE (default "
"none)\n"
msgstr ""
-#: as.c:280
+#: as.c:281
msgid " -nocpp ignored\n"
msgstr ""
-#: as.c:282
+#: as.c:283
msgid ""
" -o OBJFILE name the object-file output OBJFILE (default "
"a.out)\n"
msgstr ""
-#: as.c:284
+#: as.c:285
msgid " -R fold data section into text section\n"
msgstr ""
-#: as.c:286
+#: as.c:287
msgid ""
" --statistics print various measured statistics from execution\n"
msgstr ""
-#: as.c:288
+#: as.c:289
msgid " --strip-local-absolute strip local absolute symbols\n"
msgstr ""
-#: as.c:290
+#: as.c:291
msgid ""
" --traditional-format Use same format as native assembler when possible\n"
msgstr ""
-#: as.c:292
+#: as.c:293
msgid " --version print assembler version number and exit\n"
msgstr ""
-#: as.c:294
+#: as.c:295
msgid " -W --no-warn suppress warnings\n"
msgstr ""
-#: as.c:296
+#: as.c:297
msgid " --warn don't suppress warnings\n"
msgstr ""
-#: as.c:298
+#: as.c:299
msgid " --fatal-warnings treat warnings as errors\n"
msgstr ""
-#: as.c:300
+#: as.c:301
msgid ""
" --itbl INSTTBL extend instruction set to include instructions\n"
" matching the specifications defined in file "
"INSTTBL\n"
msgstr ""
-#: as.c:303
+#: as.c:304
msgid " -w ignored\n"
msgstr ""
-#: as.c:305
+#: as.c:306
msgid " -X ignored\n"
msgstr ""
-#: as.c:307
+#: as.c:308
msgid " -Z generate object file even after errors\n"
msgstr ""
-#: as.c:309
+#: as.c:310
msgid ""
" --listing-lhs-width set the width in words of the output data column "
"of\n"
" the listing\n"
msgstr ""
-#: as.c:312
+#: as.c:313
msgid ""
" --listing-lhs-width2 set the width in words of the continuation lines\n"
" of the output data column; ignored if smaller "
" the width of the first line\n"
msgstr ""
-#: as.c:316
+#: as.c:317
msgid ""
" --listing-rhs-width set the max width in characters of the lines from\n"
" the source file\n"
msgstr ""
-#: as.c:319
+#: as.c:320
msgid ""
" --listing-cont-lines set the maximum number of continuation lines used\n"
" for the output data column of the listing\n"
msgstr ""
-#: as.c:326 gasp.c:3554
+#: as.c:327 gasp.c:3554
#, c-format
msgid "Report bugs to %s\n"
msgstr ""
#. This output is intended to follow the GNU standards document.
-#: as.c:521
+#: as.c:522
#, c-format
msgid "GNU assembler %s\n"
msgstr ""
-#: as.c:522
+#: as.c:523
msgid "Copyright 2000 Free Software Foundation, Inc.\n"
msgstr ""
-#: as.c:523 gasp.c:3648
+#: as.c:524 gasp.c:3648
msgid ""
"This program is free software; you may redistribute it under the terms of\n"
"the GNU General Public License. This program has absolutely no warranty.\n"
msgstr ""
-#: as.c:526
+#: as.c:527
#, c-format
msgid "This assembler was configured for a target of `%s'.\n"
msgstr ""
-#: as.c:533
+#: as.c:534
msgid "multiple emulation names specified"
msgstr ""
-#: as.c:535
+#: as.c:536
msgid "emulations not handled in this configuration"
msgstr ""
-#: as.c:540
+#: as.c:541
#, c-format
msgid "alias = %s\n"
msgstr ""
-#: as.c:541
+#: as.c:542
#, c-format
msgid "canonical = %s\n"
msgstr ""
-#: as.c:542
+#: as.c:543
#, c-format
msgid "cpu-type = %s\n"
msgstr ""
-#: as.c:544
+#: as.c:545
#, c-format
msgid "format = %s\n"
msgstr ""
-#: as.c:547
+#: as.c:548
#, c-format
msgid "bfd-target = %s\n"
msgstr ""
-#: as.c:560
+#: as.c:561
msgid "bad defsym; format is --defsym name=value"
msgstr ""
-#: as.c:584
+#: as.c:585
msgid "No file name following -t option\n"
msgstr ""
-#: as.c:600
+#: as.c:601
#, c-format
msgid "Failed to read instruction table %s\n"
msgstr ""
-#: as.c:717
+#: as.c:718
#, c-format
msgid "invalid listing option `%c'"
msgstr ""
-#: as.c:911
+#: as.c:912
#, c-format
msgid "%d warnings, treating warnings as errors"
msgstr ""
-#: as.c:942
+#: as.c:943
#, c-format
msgid "%s: total time in assembly: %ld.%06ld\n"
msgstr ""
-#: as.c:945
+#: as.c:946
#, c-format
msgid "%s: data size %ld\n"
msgstr ""
msgid "Attempt to put an undefined symbol into set %s"
msgstr ""
-#: config/obj-aout.c:198 config/obj-coff.c:1211 config/obj-elf.c:1706
+#: config/obj-aout.c:198 config/obj-coff.c:1217 config/obj-elf.c:1706
#: ecoff.c:3668
#, c-format
msgid "Symbol `%s' can not be both weak and common"
msgstr ""
-#: config/obj-aout.c:256 config/obj-coff.c:1952
+#: config/obj-aout.c:256 config/obj-coff.c:1958
msgid "unresolved relocation"
msgstr ""
-#: config/obj-aout.c:258 config/obj-coff.c:1954
+#: config/obj-aout.c:258 config/obj-coff.c:1960
#, c-format
msgid "bad relocation: symbol `%s' not in symbol table"
msgstr ""
msgid "%s: bad type for weak symbol"
msgstr ""
-#: config/obj-aout.c:459 config/obj-coff.c:2885 write.c:1833
+#: config/obj-aout.c:459 config/obj-coff.c:2891 write.c:1833
#, c-format
msgid "%s: global symbols not supported in common sections"
msgstr ""
msgid "Line numbers must be positive integers\n"
msgstr ""
-#: config/obj-coff.c:484 config/obj-coff.c:2299
+#: config/obj-coff.c:484 config/obj-coff.c:2305
msgid ".ln pseudo-op inside .def/.endef: ignored."
msgstr ""
msgid ".loc pseudo-op inside .def/.endef: ignored."
msgstr ""
-#: config/obj-coff.c:622 config/obj-coff.c:2356
+#: config/obj-coff.c:622 config/obj-coff.c:2362
msgid ".def pseudo-op used inside of .def/.endef: ignored."
msgstr ""
-#: config/obj-coff.c:668 config/obj-coff.c:2409
+#: config/obj-coff.c:668 config/obj-coff.c:2415
msgid ".endef pseudo-op used outside of .def/.endef: ignored."
msgstr ""
msgid "`%s' symbol without preceding function"
msgstr ""
-#: config/obj-coff.c:760 config/obj-coff.c:2484
+#: config/obj-coff.c:760 config/obj-coff.c:2490
#, c-format
msgid "unexpected storage class %d"
msgstr ""
-#: config/obj-coff.c:873 config/obj-coff.c:2591
+#: config/obj-coff.c:873 config/obj-coff.c:2597
msgid ".dim pseudo-op used outside of .def/.endef: ignored."
msgstr ""
-#: config/obj-coff.c:893 config/obj-coff.c:2611
+#: config/obj-coff.c:893 config/obj-coff.c:2617
msgid "badly formed .dim directive ignored"
msgstr ""
-#: config/obj-coff.c:944 config/obj-coff.c:2674
+#: config/obj-coff.c:944 config/obj-coff.c:2680
msgid ".size pseudo-op used outside of .def/.endef ignored."
msgstr ""
-#: config/obj-coff.c:960 config/obj-coff.c:2690
+#: config/obj-coff.c:960 config/obj-coff.c:2696
msgid ".scl pseudo-op used outside of .def/.endef ignored."
msgstr ""
-#: config/obj-coff.c:978 config/obj-coff.c:2708
+#: config/obj-coff.c:978 config/obj-coff.c:2714
msgid ".tag pseudo-op used outside of .def/.endef ignored."
msgstr ""
-#: config/obj-coff.c:997 config/obj-coff.c:2726
+#: config/obj-coff.c:997 config/obj-coff.c:2732
#, c-format
msgid "tag not found for .tag %s"
msgstr ""
-#: config/obj-coff.c:1012 config/obj-coff.c:2741
+#: config/obj-coff.c:1012 config/obj-coff.c:2747
msgid ".type pseudo-op used outside of .def/.endef ignored."
msgstr ""
-#: config/obj-coff.c:1034 config/obj-coff.c:2763
+#: config/obj-coff.c:1034 config/obj-coff.c:2769
msgid ".val pseudo-op used outside of .def/.endef ignored."
msgstr ""
-#: config/obj-coff.c:1172 config/obj-coff.c:2958
+#: config/obj-coff.c:1178 config/obj-coff.c:2964
msgid "mismatched .eb"
msgstr ""
-#: config/obj-coff.c:1190 config/obj-coff.c:2998
+#: config/obj-coff.c:1196 config/obj-coff.c:3004
msgid "C_EFCN symbol out of scope"
msgstr ""
#. STYP_INFO
#. STYP_LIB
#. STYP_OVER
-#: config/obj-coff.c:1412
+#: config/obj-coff.c:1418
#, c-format
msgid "unsupported section attribute '%c'"
msgstr ""
-#: config/obj-coff.c:1417 config/obj-coff.c:3704 config/tc-ppc.c:3917
+#: config/obj-coff.c:1423 config/obj-coff.c:3710 config/tc-ppc.c:3917
#, c-format
msgid "unknown section attribute '%c'"
msgstr ""
-#: config/obj-coff.c:1447 config/tc-ppc.c:3935 read.c:2502
+#: config/obj-coff.c:1453 config/tc-ppc.c:3935 read.c:2509
#, c-format
msgid "error setting flags for \"%s\": %s"
msgstr ""
-#: config/obj-coff.c:1458 config/obj-elf.c:727
+#: config/obj-coff.c:1464 config/obj-elf.c:727
#, c-format
msgid "Ignoring changed section attributes for %s"
msgstr ""
-#: config/obj-coff.c:1594
+#: config/obj-coff.c:1600
#, c-format
msgid "0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"
msgstr ""
-#: config/obj-coff.c:1779 config/obj-ieee.c:69
+#: config/obj-coff.c:1785 config/obj-ieee.c:69
msgid "Out of step\n"
msgstr ""
-#: config/obj-coff.c:2214
+#: config/obj-coff.c:2220
msgid "bfd_coff_swap_scnhdr_out failed"
msgstr ""
-#: config/obj-coff.c:2441
+#: config/obj-coff.c:2447
msgid "`.bf' symbol without preceding function\n"
msgstr ""
-#: config/obj-coff.c:3401 config/obj-ieee.c:522 output-file.c:52
+#: config/obj-coff.c:3407 config/obj-ieee.c:522 output-file.c:52
#: output-file.c:119
#, c-format
msgid "FATAL: Can't create %s"
msgstr ""
-#: config/obj-coff.c:3578
+#: config/obj-coff.c:3584
#, c-format
msgid "Can't close %s: %s"
msgstr ""
-#: config/obj-coff.c:3612
+#: config/obj-coff.c:3618
#, c-format
msgid "Too many new sections; can't add \"%s\""
msgstr ""
-#: config/obj-coff.c:4022 config/tc-m88k.c:1260 config/tc-sparc.c:3454
+#: config/obj-coff.c:4028 config/tc-m88k.c:1260 config/tc-sparc.c:3454
msgid "Expected comma after name"
msgstr ""
-#: config/obj-coff.c:4028 read.c:1965
+#: config/obj-coff.c:4034 read.c:1953
msgid "Missing size expression"
msgstr ""
-#: config/obj-coff.c:4034
+#: config/obj-coff.c:4040
#, c-format
msgid "lcomm length (%d.) <0! Ignored."
msgstr ""
-#: config/obj-coff.c:4062 read.c:2186
+#: config/obj-coff.c:4068 read.c:2187
#, c-format
msgid "Symbol %s already defined"
msgstr ""
-#: config/obj-coff.c:4156 config/tc-i960.c:3255
+#: config/obj-coff.c:4162 config/tc-i960.c:3255
#, c-format
msgid "No 'bal' entry point for leafproc %s"
msgstr ""
-#: config/obj-coff.c:4235 write.c:2535
+#: config/obj-coff.c:4241 write.c:2535
#, c-format
msgid "Negative of non-absolute symbol %s"
msgstr ""
-#: config/obj-coff.c:4256 write.c:2549
+#: config/obj-coff.c:4262 write.c:2549
msgid "callj to difference of 2 symbols"
msgstr ""
-#: config/obj-coff.c:4302
+#: config/obj-coff.c:4308
#, c-format
msgid "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."
msgstr ""
#. This is a COBR instruction. They have only a 13-bit
#. displacement and are only to be used for local branches:
#. flag as error, don't generate relocation.
-#: config/obj-coff.c:4392 config/tc-i960.c:3275 write.c:2693
+#: config/obj-coff.c:4398 config/tc-i960.c:3275 write.c:2693
msgid "can't use COBR format with external label"
msgstr ""
-#: config/obj-coff.c:4472
+#: config/obj-coff.c:4478
#, c-format
msgid "Value of %ld too large for field of %d bytes at 0x%lx"
msgstr ""
-#: config/obj-coff.c:4486 write.c:2792
+#: config/obj-coff.c:4492 write.c:2792
#, c-format
msgid "Signed .word overflow; switch may be too large; %ld at 0x%lx"
msgstr ""
msgid "missing operand"
msgstr ""
-#: config/tc-a29k.c:415 config/tc-hppa.c:1563 config/tc-i860.c:407
-#: config/tc-i860.c:423 config/tc-sparc.c:1369 config/tc-sparc.c:1375
+#: config/tc-a29k.c:415 config/tc-cris.c:878 config/tc-cris.c:886
+#: config/tc-hppa.c:1563 config/tc-i860.c:407 config/tc-i860.c:423
+#: config/tc-sparc.c:1369 config/tc-sparc.c:1375
#, c-format
msgid "Unknown opcode: `%s'"
msgstr ""
#: config/tc-alpha.c:1025 config/tc-arm.c:5343 config/tc-h8300.c:1373
#: config/tc-h8500.c:1201 config/tc-hppa.c:4002 config/tc-i860.c:813
-#: config/tc-m68hc11.c:486 config/tc-m68k.c:4125 config/tc-m88k.c:1106
+#: config/tc-m68hc11.c:480 config/tc-m68k.c:4125 config/tc-m88k.c:1106
#: config/tc-ns32k.c:1590 config/tc-sparc.c:2757 config/tc-z8k.c:1354
msgid "Bad call to MD_ATOF()"
msgstr ""
msgid "macro requires $at while $at in use"
msgstr ""
-#: config/tc-alpha.c:3075 expr.c:86 read.c:3158
+#: config/tc-alpha.c:3075 expr.c:86 read.c:3161
msgid "bignum invalid; zero assumed"
msgstr ""
-#: config/tc-alpha.c:3077 expr.c:88 read.c:3160 read.c:3496 read.c:4394
+#: config/tc-alpha.c:3077 expr.c:88 read.c:3163 read.c:3496 read.c:4393
msgid "floating point number invalid; zero assumed"
msgstr ""
msgstr ""
#: config/tc-alpha.c:4291 config/tc-ppc.c:1463 config/tc-ppc.c:3681
-#: read.c:1385
+#: read.c:1366
#, c-format
msgid ".COMMon length (%ld.) <0! Ignored."
msgstr ""
#: config/tc-alpha.c:4329 config/tc-alpha.c:4338 config/tc-ppc.c:3718
-#: read.c:1406
+#: read.c:1390
#, c-format
msgid "Length of .comm \"%s\" is already %ld. Not changed to %ld."
msgstr ""
msgid "Bad .fmask directive"
msgstr ""
-#: config/tc-alpha.c:5169 config/tc-arm.c:1454 read.c:2149 read.c:2729
+#: config/tc-alpha.c:5169 config/tc-arm.c:1454 read.c:2147 read.c:2734
#: stabs.c:459
#, c-format
msgid "Expected comma after name \"%s\""
msgstr ""
#: config/tc-arc.c:1326 config/tc-arm.c:3318 config/tc-avr.c:857
-#: config/tc-d10v.c:1532 config/tc-d30v.c:1837 config/tc-mips.c:3264
-#: config/tc-mips.c:4196 config/tc-mips.c:4981 config/tc-mips.c:5527
-#: config/tc-ppc.c:4846 config/tc-v850.c:2341
+#: config/tc-cris.c:2713 config/tc-d10v.c:1532 config/tc-d30v.c:1837
+#: config/tc-mips.c:3264 config/tc-mips.c:4196 config/tc-mips.c:4981
+#: config/tc-mips.c:5527 config/tc-ppc.c:4846 config/tc-v850.c:2341
msgid "expression too complex"
msgstr ""
msgid "Invalid syntax for .req directive."
msgstr ""
-#: config/tc-arm.c:1364 config/tc-mips.c:10009 read.c:2038
+#: config/tc-arm.c:1364 config/tc-mips.c:10009 read.c:2032
#, c-format
msgid "Alignment too large: %d. assumed."
msgstr ""
-#: config/tc-arm.c:1367 read.c:2043
+#: config/tc-arm.c:1367 read.c:2037
msgid "Alignment negative. 0 assumed."
msgstr ""
-#: config/tc-arm.c:1503 config/tc-m32r.c:418 read.c:2788 read.c:4865
+#: config/tc-arm.c:1503 config/tc-m32r.c:418 read.c:2792 read.c:4853
#, c-format
msgid "symbol `%s' already defined"
msgstr ""
msgid "invalid register list to push/pop instruction"
msgstr ""
-#: config/tc-arm.c:5172
+#: config/tc-arm.c:5172 config/tc-cris.c:638
msgid "Virtual memory exhausted"
msgstr ""
msgid "Internal_relocation (type %d) not fixed up (OFFSET_IMM)"
msgstr ""
-#: config/tc-arm.c:6187 config/tc-mcore.c:2110 config/tc-ns32k.c:2284
+#: config/tc-arm.c:6187 config/tc-cris.c:2648 config/tc-mcore.c:2110
+#: config/tc-ns32k.c:2284
msgid "<unknown>"
msgstr ""
msgid "illegal %srelocation size: %d"
msgstr ""
+#: config/tc-cris.c:646
+#, c-format
+msgid "Can't hash `%s': %s\n"
+msgstr ""
+
+#: config/tc-cris.c:647
+msgid "(unknown reason)"
+msgstr ""
+
+#: config/tc-cris.c:651
+#, c-format
+msgid "Buggy opcode: `%s' \"%s\"\n"
+msgstr ""
+
+#: config/tc-cris.c:972
+#, c-format
+msgid "Immediate value not in 5 bit unsigned range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:988
+#, c-format
+msgid "Immediate value not in 4 bit unsigned range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:1028
+#, c-format
+msgid "Immediate value not in 6 bit range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:1043
+#, c-format
+msgid "Immediate value not in 6 bit unsigned range: %ld"
+msgstr ""
+
+#. Others have a generic warning.
+#: config/tc-cris.c:1130
+#, c-format
+msgid "Unimplemented register `%s' specified"
+msgstr ""
+
+#. We've come to the end of instructions with this
+#. opcode, so it must be an error.
+#: config/tc-cris.c:1281 config/tc-i860.c:725
+msgid "Illegal operands"
+msgstr ""
+
+#: config/tc-cris.c:1313 config/tc-cris.c:1344
+#, c-format
+msgid "Immediate value not in 8 bit range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:1323 config/tc-cris.c:1351
+#, c-format
+msgid "Immediate value not in 16 bit range: %ld"
+msgstr ""
+
+#. FIXME: Find out and change to as_warn_where. Add testcase.
+#: config/tc-cris.c:2303
+msgid "32-bit conditional branch generated"
+msgstr ""
+
+#. FIXME: Is this function mentioned in the internals.texi manual? If
+#. not, add it.
+#: config/tc-cris.c:2383
+msgid "Bad call to md_atof () - floating point formats are not supported"
+msgstr ""
+
+#: config/tc-cris.c:2445
+#, c-format
+msgid "Value not in 16 bit range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:2455
+#, c-format
+msgid "Value not in 8 bit range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:2462
+#, c-format
+msgid "Value not in 4 bit unsigned range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:2469
+#, c-format
+msgid "Value not in 5 bit unsigned range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:2476
+#, c-format
+msgid "Value not in 6 bit range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:2483
+#, c-format
+msgid "Value not in 6 bit unsigned range: %ld"
+msgstr ""
+
+#: config/tc-cris.c:2595
+msgid ""
+"Semantics error. This type of operand can not be relocated, it must be an "
+"assembly-time constant"
+msgstr ""
+
+#: config/tc-cris.c:2649
+#, c-format
+msgid "Cannot generate relocation type for symbol %s, code %s"
+msgstr ""
+
+#: config/tc-cris.c:2662
+msgid ""
+"\n"
+"-- GNU as for CRIS\n"
+msgstr ""
+
+#: config/tc-cris.c:2665
+msgid "*** Usage: as-cris [switches] [-o objectfile] [files...]\n"
+msgstr ""
+
+#: config/tc-cris.c:2666
+msgid "Target-specific switches:\n"
+msgstr ""
+
+#: config/tc-cris.c:2667
+msgid " -h, -H : Don't execute, print this help text.\n"
+msgstr ""
+
+#: config/tc-cris.c:2669
+msgid ""
+" -N : Warn when branches are expanded to jumps.\n"
+"\n"
+msgstr ""
+
+#: config/tc-cris.c:2670
+msgid "Use as-cris --help to see more options.\n"
+msgstr ""
+
+#: config/tc-cris.c:2671
+#, c-format
+msgid "objectfile\t: Output file in the a.out format %s"
+msgstr ""
+
+#: config/tc-cris.c:2672
+msgid "described in the users manual.\n"
+msgstr ""
+
+#: config/tc-cris.c:2673
+msgid "\t\t Default output file is \"a.out\".\n"
+msgstr ""
+
+#: config/tc-cris.c:2674
+#, c-format
+msgid "files ...\t: Input files in the source format %s"
+msgstr ""
+
+#: config/tc-cris.c:2675
+msgid " described in the users manual.\n"
+msgstr ""
+
+#: config/tc-cris.c:2676
+msgid "\t\t Default input file is standard input.\n"
+msgstr ""
+
+#: config/tc-cris.c:2677
+msgid "Description\t: Assembler for the CRIS processor.\n"
+msgstr ""
+
+#: config/tc-cris.c:2698
+msgid "Invalid relocation"
+msgstr ""
+
+#: config/tc-cris.c:2739
+msgid "Invalid pc-relative relocation"
+msgstr ""
+
+#: config/tc-cris.c:2779
+#, c-format
+msgid "Adjusted signed .word (%ld) overflows: `switch'-statement too large."
+msgstr ""
+
#: config/tc-d10v.c:235
msgid ""
"D10V options:\n"
msgid "Out of memory: could not allocate new subspace chain entry: %s\n"
msgstr ""
-#: config/tc-hppa.c:8522
+#: config/tc-hppa.c:8523
#, c-format
msgid "Symbol '%s' could not be created."
msgstr ""
-#: config/tc-hppa.c:8526
+#: config/tc-hppa.c:8527
msgid "No memory for symbol name."
msgstr ""
msgid "5-bit immediate too large"
msgstr ""
-#: config/tc-i860.c:725
-msgid "Illegal operands"
-msgstr ""
-
#: config/tc-i860.c:749 config/tc-sparc.c:2660
msgid "bad segment"
msgstr ""
"is this intentional ?"
msgstr ""
-#: config/tc-m32r.c:1235 config/tc-ppc.c:1455 config/tc-ppc.c:3673 read.c:1376
+#: config/tc-m32r.c:1235 config/tc-ppc.c:1455 config/tc-ppc.c:3673 read.c:1355
msgid "Expected comma after symbol-name: rest of line ignored."
msgstr ""
msgid "ignoring bad alignment"
msgstr ""
-#: config/tc-m32r.c:1284 config/tc-ppc.c:1488 config/tc-ppc.c:3709 read.c:1396
-#: read.c:2109
+#: config/tc-m32r.c:1284 config/tc-ppc.c:1488 config/tc-ppc.c:3709 read.c:1379
+#: read.c:2105
#, c-format
msgid "Ignoring attempt to re-define symbol `%s'."
msgstr ""
msgid "Unmatched high/shigh reloc"
msgstr ""
-#: config/tc-m68hc11.c:312
+#: config/tc-m68hc11.c:307
#, c-format
msgid ""
"Motorola 68HC11/68HC12 options:\n"
" (used for testing)\n"
msgstr ""
-#: config/tc-m68hc11.c:353
+#: config/tc-m68hc11.c:348
#, c-format
msgid "Default target `%s' is not supported."
msgstr ""
#. Dump the opcode statistics table.
-#: config/tc-m68hc11.c:372
+#: config/tc-m68hc11.c:367
msgid "Name # Modes Min ops Max ops Modes mask # Used\n"
msgstr ""
-#: config/tc-m68hc11.c:422
+#: config/tc-m68hc11.c:417
#, c-format
msgid "Option `%s' is not recognized."
msgstr ""
-#: config/tc-m68hc11.c:646
+#: config/tc-m68hc11.c:638
msgid "#<imm8>"
msgstr ""
-#: config/tc-m68hc11.c:655
+#: config/tc-m68hc11.c:647
msgid "#<imm16>"
msgstr ""
-#: config/tc-m68hc11.c:664 config/tc-m68hc11.c:673
+#: config/tc-m68hc11.c:656 config/tc-m68hc11.c:665
msgid "<imm8>,X"
msgstr ""
-#: config/tc-m68hc11.c:691
+#: config/tc-m68hc11.c:683
msgid "*<abs8>"
msgstr ""
-#: config/tc-m68hc11.c:703
+#: config/tc-m68hc11.c:695
msgid "#<mask>"
msgstr ""
-#: config/tc-m68hc11.c:713
+#: config/tc-m68hc11.c:705
#, c-format
msgid "symbol%d"
msgstr ""
-#: config/tc-m68hc11.c:715
+#: config/tc-m68hc11.c:707
msgid "<abs>"
msgstr ""
-#: config/tc-m68hc11.c:734
+#: config/tc-m68hc11.c:726
msgid "<label>"
msgstr ""
-#: config/tc-m68hc11.c:751
+#: config/tc-m68hc11.c:742
#, c-format
msgid ""
"# Example of `%s' instructions\n"
"_start:\n"
msgstr ""
-#: config/tc-m68hc11.c:801
+#: config/tc-m68hc11.c:790
#, c-format
msgid "Instruction `%s' is not recognized."
msgstr ""
-#: config/tc-m68hc11.c:806
+#: config/tc-m68hc11.c:795
#, c-format
msgid "Instruction formats for `%s':"
msgstr ""
-#: config/tc-m68hc11.c:944
+#: config/tc-m68hc11.c:928
#, c-format
msgid "Immediate operand is not allowed for operand %d."
msgstr ""
-#: config/tc-m68hc11.c:970
+#: config/tc-m68hc11.c:954
msgid "Indirect indexed addressing is not valid for 68HC11."
msgstr ""
-#: config/tc-m68hc11.c:990
+#: config/tc-m68hc11.c:974
msgid "Spurious `,' or bad indirect register addressing mode."
msgstr ""
-#: config/tc-m68hc11.c:1006
+#: config/tc-m68hc11.c:990
msgid "Missing second register or offset for indexed-indirect mode."
msgstr ""
-#: config/tc-m68hc11.c:1016
+#: config/tc-m68hc11.c:1000
msgid "Missing second register for indexed-indirect mode."
msgstr ""
-#: config/tc-m68hc11.c:1032
+#: config/tc-m68hc11.c:1016
msgid "Missing `]' to close indexed-indirect mode."
msgstr ""
-#: config/tc-m68hc11.c:1076
+#: config/tc-m68hc11.c:1060
msgid "Illegal operand."
msgstr ""
-#: config/tc-m68hc11.c:1081
+#: config/tc-m68hc11.c:1065
msgid "Missing operand."
msgstr ""
-#: config/tc-m68hc11.c:1104
+#: config/tc-m68hc11.c:1088
msgid "Pre-decrement mode is not valid for 68HC11"
msgstr ""
-#: config/tc-m68hc11.c:1111
+#: config/tc-m68hc11.c:1095
msgid "Pre-increment mode is not valid for 68HC11"
msgstr ""
-#: config/tc-m68hc11.c:1130
+#: config/tc-m68hc11.c:1114
msgid "Wrong register in register indirect mode."
msgstr ""
-#: config/tc-m68hc11.c:1138
+#: config/tc-m68hc11.c:1122
msgid "Missing `]' to close register indirect operand."
msgstr ""
-#: config/tc-m68hc11.c:1155
+#: config/tc-m68hc11.c:1139
msgid "Post-decrement mode is not valid for 68HC11."
msgstr ""
-#: config/tc-m68hc11.c:1163
+#: config/tc-m68hc11.c:1147
msgid "Post-increment mode is not valid for 68HC11."
msgstr ""
-#: config/tc-m68hc11.c:1180
+#: config/tc-m68hc11.c:1164
msgid "Invalid indexed indirect mode."
msgstr ""
-#: config/tc-m68hc11.c:1281
+#: config/tc-m68hc11.c:1258
#, c-format
msgid "Trap id `%ld' is out of range."
msgstr ""
-#: config/tc-m68hc11.c:1285
+#: config/tc-m68hc11.c:1262
msgid "Trap id must be within [0x30..0x39] or [0x40..0xff]."
msgstr ""
-#: config/tc-m68hc11.c:1292
+#: config/tc-m68hc11.c:1269
#, c-format
msgid "Operand out of 8-bit range: `%ld'."
msgstr ""
-#: config/tc-m68hc11.c:1299
+#: config/tc-m68hc11.c:1276
msgid "The trap id must be a constant."
msgstr ""
-#: config/tc-m68hc11.c:1324
+#: config/tc-m68hc11.c:1301
#, c-format
msgid "Operand `%x' not recognized in fixup8."
msgstr ""
-#: config/tc-m68hc11.c:1344
+#: config/tc-m68hc11.c:1321
#, c-format
msgid "Operand out of 16-bit range: `%ld'."
msgstr ""
-#: config/tc-m68hc11.c:1365
+#: config/tc-m68hc11.c:1342
#, c-format
msgid "Operand `%x' not recognized in fixup16."
msgstr ""
-#: config/tc-m68hc11.c:1384
+#: config/tc-m68hc11.c:1360
#, c-format
msgid "Unexpected branch conversion with `%x'"
msgstr ""
-#: config/tc-m68hc11.c:1480 config/tc-m68hc11.c:1609
+#: config/tc-m68hc11.c:1456 config/tc-m68hc11.c:1585
#, c-format
msgid "Operand out of range for a relative branch: `%ld'"
msgstr ""
-#: config/tc-m68hc11.c:1577
+#: config/tc-m68hc11.c:1553
msgid "Invalid register for dbcc/tbcc instruction."
msgstr ""
-#: config/tc-m68hc11.c:1668
+#: config/tc-m68hc11.c:1644
#, c-format
msgid "Increment/decrement value is out of range: `%ld'."
msgstr ""
-#: config/tc-m68hc11.c:1679
+#: config/tc-m68hc11.c:1655
msgid "Expecting a register."
msgstr ""
-#: config/tc-m68hc11.c:1694
+#: config/tc-m68hc11.c:1670
msgid "Invalid register for post/pre increment."
msgstr ""
-#: config/tc-m68hc11.c:1724
+#: config/tc-m68hc11.c:1700
msgid "Invalid register."
msgstr ""
-#: config/tc-m68hc11.c:1731
+#: config/tc-m68hc11.c:1707
#, c-format
msgid "Offset out of 16-bit range: %ld."
msgstr ""
-#: config/tc-m68hc11.c:1736
+#: config/tc-m68hc11.c:1712
msgid "Offset out of 5-bit range for movw/movb insn."
msgstr ""
-#: config/tc-m68hc11.c:1789
+#: config/tc-m68hc11.c:1766
msgid "Expecting register D for indexed indirect mode."
msgstr ""
-#: config/tc-m68hc11.c:1791
+#: config/tc-m68hc11.c:1768
msgid "Indexed indirect mode is not allowed for movb/movw."
msgstr ""
-#: config/tc-m68hc11.c:1808
+#: config/tc-m68hc11.c:1785
msgid "Invalid accumulator register."
msgstr ""
-#: config/tc-m68hc11.c:1833
+#: config/tc-m68hc11.c:1810
msgid "Invalid indexed register."
msgstr ""
-#: config/tc-m68hc11.c:1841
+#: config/tc-m68hc11.c:1818
msgid "Addressing mode not implemented yet."
msgstr ""
-#: config/tc-m68hc11.c:1856
+#: config/tc-m68hc11.c:1833
msgid "Invalid source register for this instruction, use 'tfr'."
msgstr ""
-#: config/tc-m68hc11.c:1858
+#: config/tc-m68hc11.c:1835
msgid "Invalid source register."
msgstr ""
-#: config/tc-m68hc11.c:1863
+#: config/tc-m68hc11.c:1840
msgid "Invalid destination register for this instruction, use 'tfr'."
msgstr ""
-#: config/tc-m68hc11.c:1865
+#: config/tc-m68hc11.c:1842
msgid "Invalid destination register."
msgstr ""
-#: config/tc-m68hc11.c:1954
+#: config/tc-m68hc11.c:1931
msgid "Invalid indexed register, expecting register X."
msgstr ""
-#: config/tc-m68hc11.c:1956
+#: config/tc-m68hc11.c:1933
msgid "Invalid indexed register, expecting register Y."
msgstr ""
-#: config/tc-m68hc11.c:2251
+#: config/tc-m68hc11.c:2222
msgid "No instruction or missing opcode."
msgstr ""
-#: config/tc-m68hc11.c:2316
+#: config/tc-m68hc11.c:2287
#, c-format
msgid "Opcode `%s' is not recognized."
msgstr ""
-#: config/tc-m68hc11.c:2338
+#: config/tc-m68hc11.c:2309
#, c-format
msgid "Garbage at end of instruction: `%s'."
msgstr ""
-#: config/tc-m68hc11.c:2361
+#: config/tc-m68hc11.c:2332
#, c-format
msgid "Invalid operand for `%s'"
msgstr ""
-#: config/tc-m68hc11.c:2420
+#: config/tc-m68hc11.c:2389
#, c-format
msgid "Relocation %d is not supported by object file format."
msgstr ""
-#: config/tc-m68hc11.c:2575
+#: config/tc-m68hc11.c:2544
msgid "bra or bsr with undefined symbol."
msgstr ""
-#: config/tc-m68hc11.c:2683
+#: config/tc-m68hc11.c:2652
#, c-format
msgid "Subtype %d is not recognized."
msgstr ""
-#: config/tc-m68hc11.c:2720
+#: config/tc-m68hc11.c:2689
msgid "Expression too complex."
msgstr ""
-#: config/tc-m68hc11.c:2749
+#: config/tc-m68hc11.c:2718
msgid "Value out of 16-bit range."
msgstr ""
-#: config/tc-m68hc11.c:2768
+#: config/tc-m68hc11.c:2741
#, c-format
msgid "Value %ld too large for 8-bit PC-relative branch."
msgstr ""
-#: config/tc-m68hc11.c:2775
+#: config/tc-m68hc11.c:2748
#, c-format
msgid "Auto increment/decrement offset '%ld' is out of range."
msgstr ""
-#: config/tc-m68hc11.c:2786
+#: config/tc-m68hc11.c:2759
#, c-format
msgid "Line %d: unknown relocation type: 0x%x."
msgstr ""
msgid "Relaxation should never occur"
msgstr ""
-#: config/tc-m88k.c:1267 config/tc-sparc.c:3463 read.c:1971
+#: config/tc-m88k.c:1267 config/tc-sparc.c:3463 read.c:1959
#, c-format
msgid "BSS length (%d.) <0! Ignored."
msgstr ""
msgid "The XCOFF file format does not support arbitrary sections"
msgstr ""
-#: config/tc-ppc.c:2772 config/tc-ppc.c:3297 read.c:2983
+#: config/tc-ppc.c:2772 config/tc-ppc.c:3297 read.c:2989
msgid "missing value"
msgstr ""
msgid "Character constant too large"
msgstr ""
-#: expr.c:956
+#: expr.c:962
#, c-format
msgid "expr.c(operand): bad atof_generic return val %d"
msgstr ""
-#: expr.c:1019
+#: expr.c:1025
#, c-format
msgid "Missing '%c' assumed"
msgstr ""
-#: expr.c:1031 read.c:3864
+#: expr.c:1037 read.c:3865
msgid "EBCDIC constants are not supported"
msgstr ""
-#: expr.c:1101
+#: expr.c:1107
#, c-format
msgid "Unary operator %c ignored because bad operand follows"
msgstr ""
-#: expr.c:1147 expr.c:1172
+#: expr.c:1153 expr.c:1178
msgid "syntax error in .startof. or .sizeof."
msgstr ""
-#: expr.c:1322
+#: expr.c:1328
msgid "Bad expression"
msgstr ""
-#: expr.c:1690
+#: expr.c:1696
msgid "missing operand; zero assumed"
msgstr ""
-#: expr.c:1723
+#: expr.c:1729
msgid "operation combines symbols in different segments"
msgstr ""
-#: expr.c:1739
+#: expr.c:1745
msgid "left operand is a bignum; integer 0 assumed"
msgstr ""
-#: expr.c:1741
+#: expr.c:1747
msgid "left operand is a float; integer 0 assumed"
msgstr ""
-#: expr.c:1750
+#: expr.c:1756
msgid "right operand is a bignum; integer 0 assumed"
msgstr ""
-#: expr.c:1752
+#: expr.c:1758
msgid "right operand is a float; integer 0 assumed"
msgstr ""
-#: expr.c:1807 symbols.c:1109
+#: expr.c:1813 symbols.c:1109
msgid "division by zero"
msgstr ""
msgid "Can't continue"
msgstr ""
-#: read.c:452
+#: read.c:451
#, c-format
msgid "error constructing %s pseudo-op table: %s"
msgstr ""
-#: read.c:817
+#: read.c:801
#, c-format
msgid "Unknown pseudo-op: `%s'"
msgstr ""
-#: read.c:950
+#: read.c:933
#, c-format
msgid "label \"%d$\" redefined"
msgstr ""
-#: read.c:1167
+#: read.c:1144
msgid ".abort detected. Abandoning ship."
msgstr ""
-#: read.c:1258 read.c:2031
+#: read.c:1235 read.c:2024
msgid "Alignment not a power of 2"
msgstr ""
-#: read.c:1266
+#: read.c:1244
#, c-format
msgid "Alignment too large: %u assumed"
msgstr ""
-#: read.c:1298
+#: read.c:1276
msgid "expected fill pattern missing"
msgstr ""
-#: read.c:1495
+#: read.c:1480
#, c-format
msgid "attempt to re-define symbol `%s'"
msgstr ""
#. Some of the back ends can't deal with non-positive line numbers.
#. Besides, it's silly.
-#: read.c:1619
+#: read.c:1604
#, c-format
msgid "Line numbers must be positive; line number %d rejected."
msgstr ""
-#: read.c:1646
+#: read.c:1632
msgid "start address not supported"
msgstr ""
-#: read.c:1656
+#: read.c:1642
msgid ".err encountered"
msgstr ""
-#: read.c:1675 read.c:1677
+#: read.c:1661 read.c:1663
#, c-format
msgid ".fail %ld encountered"
msgstr ""
-#: read.c:1714
+#: read.c:1700
#, c-format
msgid ".fill size clamped to %d."
msgstr ""
-#: read.c:1719
+#: read.c:1705
msgid "Size negative: .fill ignored."
msgstr ""
-#: read.c:1725
+#: read.c:1711
msgid "Repeat < 0, .fill ignored"
msgstr ""
-#: read.c:1883
+#: read.c:1871
#, c-format
msgid "unrecognized .linkonce type `%s'"
msgstr ""
-#: read.c:1896 read.c:1922
+#: read.c:1884 read.c:1910
msgid ".linkonce is not supported for this object file format"
msgstr ""
-#: read.c:1918
+#: read.c:1906
#, c-format
msgid "bfd_set_section_flags: %s"
msgstr ""
-#: read.c:1987
+#: read.c:1975
#, c-format
msgid "error setting flags for \".sbss\": %s"
msgstr ""
-#: read.c:2009
+#: read.c:1998
msgid "Expected comma after size"
msgstr ""
-#: read.c:2017
+#: read.c:2008
msgid "Missing alignment"
msgstr ""
msgid "bad expression"
msgstr ""
-#: read.c:2290
+#: read.c:2296
#, c-format
msgid "attempt to redefine pseudo-op `%s' ignored"
msgstr ""
-#: read.c:2356
+#: read.c:2362
#, c-format
msgid "invalid segment \"%s\"; segment \"%s\" assumed"
msgstr ""
-#: read.c:2362
+#: read.c:2368
msgid "ignoring fill value in absolute section"
msgstr ""
-#: read.c:2365
+#: read.c:2371
msgid "only constant offsets supported in absolute section"
msgstr ""
-#: read.c:2397
+#: read.c:2403
msgid "MRI style ORG pseudo-op not supported"
msgstr ""
-#: read.c:2485
+#: read.c:2492
msgid "unrecognized section type"
msgstr ""
-#: read.c:2553
+#: read.c:2560
#, c-format
msgid "unrecognized section type `%s'"
msgstr ""
-#: read.c:2567
+#: read.c:2574
msgid "absolute sections are not supported"
msgstr ""
-#: read.c:2582
+#: read.c:2589
#, c-format
msgid "unrecognized section command `%s'"
msgstr ""
-#: read.c:2670
+#: read.c:2677
#, c-format
msgid "%s without %s"
msgstr ""
-#: read.c:2874
+#: read.c:2878
msgid "Unsupported variable size or fill value"
msgstr ""
-#: read.c:2899
+#: read.c:2903
msgid ".space repeat count is zero, ignored"
msgstr ""
-#: read.c:2901
+#: read.c:2905
msgid ".space repeat count is negative, ignored"
msgstr ""
-#: read.c:2930
+#: read.c:2934
msgid "space allocation too complex in absolute section"
msgstr ""
-#: read.c:2935
+#: read.c:2940
msgid "space allocation too complex in common section"
msgstr ""
-#: read.c:3022 read.c:4111
+#: read.c:3028 read.c:4110
#, c-format
msgid "Bad floating literal: %s"
msgstr ""
-#: read.c:3098
+#: read.c:3101
#, c-format
msgid "Rest of line ignored. First ignored character is `%c'."
msgstr ""
-#: read.c:3101
+#: read.c:3104
#, c-format
msgid "Rest of line ignored. First ignored character valued 0x%x."
msgstr ""
-#: read.c:3152
+#: read.c:3155
msgid "illegal expression; zero assumed"
msgstr ""
-#: read.c:3154
+#: read.c:3157
msgid "missing expression; zero assumed"
msgstr ""
-#: read.c:3327
+#: read.c:3328
msgid "rva without symbol"
msgstr ""
msgid "attempt to store value in absolute section"
msgstr ""
-#: read.c:3490 read.c:4388
+#: read.c:3490 read.c:4387
msgid "zero assumed for missing expression"
msgstr ""
-#: read.c:3502 read.c:4400
+#: read.c:3502 read.c:4399
msgid "register value used as expression"
msgstr ""
msgid "unsupported BFD relocation size %u"
msgstr ""
-#: read.c:3774
+#: read.c:3775
msgid "using a bit field width of zero"
msgstr ""
-#: read.c:3782
+#: read.c:3783
#, c-format
msgid "field width \"%s\" too complex for a bitfield"
msgstr ""
-#: read.c:3790
+#: read.c:3791
#, c-format
msgid "field width %lu too big to fit in %d bytes: truncated to %d bits"
msgstr ""
-#: read.c:3811
+#: read.c:3812
#, c-format
msgid "field value \"%s\" too complex for a bitfield"
msgstr ""
-#: read.c:3935
+#: read.c:3938
msgid "Unresolvable or nonpositive repeat count; using 1"
msgstr ""
-#: read.c:3986
+#: read.c:3989
#, c-format
msgid "Unknown floating type type '%c'"
msgstr ""
-#: read.c:4008
+#: read.c:4011
msgid "Floating point constant too large"
msgstr ""
-#: read.c:4133
+#: read.c:4132
msgid "unresolvable or nonpositive repeat count; using 1"
msgstr ""
-#: read.c:4537
+#: read.c:4530
msgid "Expected <nn>"
msgstr ""
#. To be compatible with BSD 4.2 as: give the luser a linefeed!!
-#: read.c:4570 read.c:4653
+#: read.c:4563 read.c:4649
msgid "Unterminated string: Newline inserted."
msgstr ""
-#: read.c:4661
+#: read.c:4657
msgid "Bad escaped character in string, '?' assumed"
msgstr ""
-#: read.c:4687
+#: read.c:4683
msgid "expected address expression; zero assumed"
msgstr ""
-#: read.c:4707
+#: read.c:4703
#, c-format
msgid "symbol \"%s\" undefined; zero assumed"
msgstr ""
-#: read.c:4710
+#: read.c:4706
msgid "some symbol undefined; zero assumed"
msgstr ""
-#: read.c:4728
+#: read.c:4724
msgid "bad or irreducible absolute expression; zero assumed"
msgstr ""
-#: read.c:4766
+#: read.c:4759
msgid "This string may not contain '\\0'"
msgstr ""
-#: read.c:4805
+#: read.c:4796
msgid "Missing string"
msgstr ""
-#: read.c:5034
+#: read.c:5027
msgid "missing .func"
msgstr ""
-#: read.c:5051
+#: read.c:5044
msgid ".endfunc missing for previous .func"
msgstr ""
projects / thirdparty / binutils-gdb.git / commitdiff
